Hola,en esta ocasión les dejo un código que simula el funcionamiento neuronal del cerebro humano basado en el modelo básico de un perceptron,dicho modelo se encarga de simular el previo funcionamiento de una neurona natural con un conjunto de formulas que permiten comparar numeraciones y datos.

Como verán,el modelo básico toma por una serie de entradas cada datos en forma binaria o por 1,-1 y los compara con el peso para llegar a una conclusión, es decir por ejemplo , de entrada están los datos -1,1,-1 los compara con los pesos establecidos -1,1,1, los multiplica uno por uno y los suma y se llega a una conclusión,esta se aplasta por una función lineal que resultara un numero negativo o positivo,el cual el negativo es «mal» y el positivo es «bien».

Recree el proceso en un pequeño fragmento en python,el codigo es el siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def neurona(entrada,peso):#Valores de entradas y valores de "peso"
    c = 0                                  #conteo
    multiplicados = []                   #buffer 1
    for entrada1 in entrada:              #intera sobre la entradas
        analisis1 = entrada1 * peso[c]   #multiplica las entradas por los pesos
        multiplicados.append(analisis1)  #la aniade al buffer
        c +=1                              #esto aumenta el conteo para ver el peso a medida que se repite el bucle
    suma = 0                             #buffer de suma    
    for i in multiplicados:                 #intera sobre
        suma+=i                             #va sumando a suma para sacar el resultado
    peso = math.tanh(suma)               #calculo funcional para reprimir el valor de suma
    if suma == len(entrada):             #si la suma es igual a la cantidad de valores entrada
        return suma                      #devolver la suma
    return peso

Hace todo el calculo explicado al comienzo,toma un patrón primario que es el de entrada y un secundario que es el de nivel de peso.
Ej: comparar [-1,1] con [-1,1] ,va a decir que son iguales,pero si comparamos [-1,-1] con [-1,1] va a notar una diferencia en 0,y si comparamos [-1,-1] con [1,1] va arrojar un numero negativo decimal encorde a la función aplicada.

El siguiente programa es un ejemplo de donde se podria usar este sistema:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
    import math
    import cPickle
    from Tkinter import *
    from tkMessageBox import *
    def crear():
            db = []
            cPickle.dump(db,open("memoria.mem","wb"))
     
    matriz = [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
     
    memoria = cPickle.load(open("memoria.mem","rb"))
     
    def imp(que,rango):#imprimir matriz
            ac = 0
            if ac==1:
                    c = 0
                    c1 = rango
                   
                    print "=================="
                    for i in range(0,rango):
                            a = que[c:c1]
                            k =  "       ".join(str(o)for o in a)
                            print ""
                            print k
                            c +=rango
                            c1+=rango
                    print "========================"
            else:
                    pass
    def imp2(que,rango):#imprimir matriz auxiliar
            ac = 1
            if ac==1:
                    c = 0
                    c1 = rango
                   
                    print "=================="
                    for i in range(0,rango):
                            a = que[c:c1]
                            k =  "       ".join(str(o)for o in a)
                            print ""
                            print k
                            c +=rango
                            c1+=rango
                    print "========================"
            else:
                    pass
     
    def neurona(entrada,peso):#Valores de entradas y valores de "peso"
            c = 0                                                            #conteo
            multiplicados = []                               #buffer 1
            for entrada1 in entrada:                         #intera sobre la entradas
                    analisis1 = entrada1 * peso[c]   #multiplica las entradas por los pesos
                    multiplicados.append(analisis1)  #la aniade al buffer
                    c +=1                                                    #esto aumenta el conteo para ver el peso a medida que se repite el bucle
            suma = 0                                                         #buffer de suma      
            for i in multiplicados:                          #intera sobre
                    suma+=i                                                  #va sumando a suma para sacar el resultado
            peso = math.tanh(suma)               #calculo funcional para reprimir el valor de suma
            if suma == len(entrada):             #si la suma es igual a la cantidad de valores entrada
                    return suma                      #devolver la suma
            return peso
     
    def final():
            global candidatos,y
            candidatos = {}
            z = 0
            for i in memoria:
                    peso = neurona(memoria[z],matriz)
                    print "peso:",peso
                    if peso <= 0.9999999999:
                            pass
                    else:
                            candidatos[peso] = memoria[z]
                    z+=1
                   
            y = 0
            for m in candidatos:
                    if m > y:
                            y = 0
                            y +=m
                    else:
                            pass
                           
            if candidatos == {}:
                    print "No se que es"
            else:
                    print "Comparado ",matriz," con ",candidatos[y]
                    print "asd:",matriz
                    print "RESULTA:"
                    imp2(candidatos[y],5)
            print candidatos
    def aprender():
            def memorizar(palabra,lon):
                    matriz=[]
                    c = 0
                    c1= 0
                    for i in range(0,len(palabra)):
                            for i in palabra:
                                    matriz.append(palabra[c1]*palabra[c])
                                    c+=1
                            c = 0
                            c1+=1
                    imp(matriz,lon)
                    return matriz
            a =  memorizar(matriz,25)
            memoria.append(a[0:25])
            memoria.reverse()
            print "Matriz aprendida:"
            for t in memoria:
                    print t
            cPickle.dump(memoria,open("memoria.mem","wb"))
            resetear_tabla()
     
    def analizar():
            final()
            resetear_tabla()
            rellenar()
     
                   
    #################INTERFAZ GRAFIC
    ventana = Tk()
    class  nume:
            def una(self):
                    matriz[0] = 1
                    button1.config(bg="#5BADFF")
                    imp(matriz,5)
            def dos(self):
                    matriz[1] = 1
                    button2.config(bg="#5BADFF")
                    imp(matriz,5)
            def tres(self):
                    matriz[2] = 1
                    button3.config(bg="#5BADFF")
                    imp(matriz,5)
            def cuatro(self):
                    matriz[3] = 1
                    button4.config(bg="#5BADFF")
                    imp(matriz,5)
            def cinco(self):
                    matriz[4] = 1
                    button5.config(bg="#5BADFF")
                    imp(matriz,5)
            def seis(self):
                    matriz[5] = 1
                    button6.config(bg="#5BADFF")
                    imp(matriz,5)
            def siete(self):
                    matriz[6] = 1
                    button7.config(bg="#5BADFF")
                    imp(matriz,5)
            def ocho(self):
                    matriz[7] = 1
                    button8.config(bg="#5BADFF")
                    imp(matriz,5)
            def nueve(self):
                    matriz[8] = 1
                    button9.config(bg="#5BADFF")
                    imp(matriz,5)
            def diez(self):
                    matriz[9] = 1
                    button10.config(bg="#5BADFF")
                    imp(matriz,5)
            def once(self):
                    matriz[10] = 1
                    button11.config(bg="#5BADFF")
                    imp(matriz,5)
            def doce(self):
                    matriz[11] = 1
                    button12.config(bg="#5BADFF")
                    imp(matriz,5)
            def trece(self):
                    matriz[12] = 1
                    button13.config(bg="#5BADFF")
                    imp(matriz,5)
     
            def catorce(self):
                    matriz[13] = 1
                    button14.config(bg="#5BADFF")
                    imp(matriz,5)
                   
            def quince(self):
                    matriz[14] = 1
                    button15.config(bg="#5BADFF")
                    imp(matriz,5)
     
            def diesiseis(self):
                    matriz[15] = 1
                    button16.config(bg="#5BADFF")
                    imp(matriz,5)
     
            def diesisiete(self):
                    matriz[16] = 1
                    button17.config(bg="#5BADFF")
                    imp(matriz,5)
     
            def diesiocho(self):
                    matriz[17] = 1
                    button18.config(bg="#5BADFF")
                    imp(matriz,5)
                   
            def diesinueve(self):
                    matriz[18] = 1
                    button19.config(bg="#5BADFF")
                    imp(matriz,5)
            def veinte(self):
                    matriz[19] = 1
                    button20.config(bg="#5BADFF")
                    imp(matriz,5)
     
            def veintiuno(self):
                    matriz[20] = 1
                    button21.config(bg="#5BADFF")
                    imp(matriz,5)
            def veintidos(self):
                    matriz[21] = 1
                    button22.config(bg="#5BADFF")
                    imp(matriz,5)
                   
            def veintitres(self):
                    matriz[22] = 1
                    button23.config(bg="#5BADFF")
                    imp(matriz,5)
                   
            def veinticuatro(self):
                    matriz[23] = 1
                    button24.config(bg="#5BADFF")
                    imp(matriz,5)
     
            def veinticinco(self):
                    matriz[24] = 1
                    button25.config(bg="#5BADFF")
                    imp(matriz,5)
    core = nume()
    def resetear_tabla():
            c = 0
            for i in matriz:
                    matriz[c] = -1
                    c+=1
            for t in botones:
                    t.config(bg="#FFFFFF")
    def borrarmem():
            memoria = []
            cPickle.dump(memoria,open("memoria.mem","wb"))
     
    def rellenar():
            c = 0
            if candidatos == {}:
                    return 0
            for i in candidatos[y]:
                   
                    if c == len(botones):
                            break
                    if i == 1:
                            botones[c].config(bg="#01D826")
                    if i == -1:
                            pass
                    c+=1
     
     
     
     
     
     
     
     
     
     
     
    ###botones interac
    ventana2 = Tk()
    ventana.title("Mem  by Rokerlauncher96")
    ventana.config(bg="#ECFFFF")
    ventana2.geometry("180x200+450+350")
    ventana2.title("Panel")
     
    ventana.geometry("300x300+100+100")
    aprender=Button(ventana2,text='Aprender',command=aprender,width=455).pack()
    aprender=Button(ventana2,text='Analizar',command=analizar,width=455).pack()
    aprender=Button(ventana2,text='Resetear valores',command=resetear_tabla,width=455).pack()
    Label(ventana2,text="_____________________________").pack()
    aprender=Button(ventana2,text='Borrar memoria',command=borrarmem,width=455).pack()
    #######5
    button25=Button(ventana,text='25',command=core.veinticinco,bg="#FFFFFF")
    button25.place(relx=0.73, rely=0.77, relwidth=0.13, relheight=0.15)
    button24=Button(ventana,text='24',command=core.veinticuatro,bg="#FFFFFF")
    button24.place(relx=0.58, rely=0.77, relwidth=0.13, relheight=0.15)
    button23=Button(ventana,text='23',command=core.veintitres,bg="#FFFFFF")
    button23.place(relx=0.43, rely=0.77, relwidth=0.13, relheight=0.15)
    button22=Button(ventana,text='22',command=core.veintidos,bg="#FFFFFF")
    button22.place(relx=0.28, rely=0.77, relwidth=0.13, relheight=0.15)
    button21=Button(ventana,text='21',command=core.veintiuno,bg="#FFFFFF")
    button21.place(relx=0.12, rely=0.77, relwidth=0.13, relheight=0.15)
    #######4
    button20=Button(ventana,text='20',command=core.veinte,bg="#FFFFFF")
    button20.place(relx=0.73, rely=0.60, relwidth=0.13, relheight=0.15)
    button19=Button(ventana,text='19',command=core.diesinueve,bg="#FFFFFF")
    button19.place(relx=0.58, rely=0.60, relwidth=0.13, relheight=0.15)
    button18=Button(ventana,text='18',command=core.diesiocho,bg="#FFFFFF")
    button18.place(relx=0.43, rely=0.60, relwidth=0.13, relheight=0.15)
    button17=Button(ventana,text='17',command=core.diesisiete,bg="#FFFFFF")
    button17.place(relx=0.28, rely=0.60, relwidth=0.13, relheight=0.15)
    button16=Button(ventana,text='16',command=core.diesiseis,bg="#FFFFFF")
    button16.place(relx=0.12, rely=0.60, relwidth=0.13, relheight=0.15)
    #######3
    button15=Button(ventana,text='15',command=core.quince,bg="#FFFFFF")
    button15.place(relx=0.73, rely=0.43, relwidth=0.13, relheight=0.15)
    button14=Button(ventana,text='14',command=core.catorce,bg="#FFFFFF")
    button14.place(relx=0.58, rely=0.43, relwidth=0.13, relheight=0.15)
    button13=Button(ventana,text='13',command=core.trece,bg="#FFFFFF")
    button13.place(relx=0.43, rely=0.43, relwidth=0.13, relheight=0.15)
    button12=Button(ventana,text='12',command=core.doce,bg="#FFFFFF")
    button12.place(relx=0.28, rely=0.43, relwidth=0.13, relheight=0.15)
    button11=Button(ventana,text='11',command=core.once,bg="#FFFFFF")
    button11.place(relx=0.12, rely=0.43, relwidth=0.13, relheight=0.15)
    #######2
    diez = button10=Button(ventana,text='10',command=core.diez,bg="#FFFFFF")
    button10.place(relx=0.73, rely=0.26, relwidth=0.13, relheight=0.15)
    nueve = button9=Button(ventana,text='9',command=core.nueve,bg="#FFFFFF")
    button9.place(relx=0.58, rely=0.26, relwidth=0.13, relheight=0.15)
    ocho = button8=Button(ventana,text='8',command=core.ocho,bg="#FFFFFF")
    button8.place(relx=0.43, rely=0.26, relwidth=0.13, relheight=0.15)
    siete = button7=Button(ventana,text='7',command=core.siete,bg="#FFFFFF")
    button7.place(relx=0.28, rely=0.26, relwidth=0.13, relheight=0.15)
    seis = button6=Button(ventana,text='6',command=core.seis,bg="#FFFFFF")
    button6.place(relx=0.12, rely=0.26, relwidth=0.13, relheight=0.15)
    #######1
    cinco1 = button5=Button(ventana,text='5',command=core.cinco,bg="#FFFFFF")
    button5.place(relx=0.73, rely=0.09, relwidth=0.13, relheight=0.15)
    cuatro1 = button4=Button(ventana,text='4',command=core.cuatro,bg="#FFFFFF")
    button4.place(relx=0.58, rely=0.09, relwidth=0.13, relheight=0.15)
    tres1 = button3=Button(ventana,text='3',command=core.tres,bg="#FFFFFF")
    button3.place(relx=0.43, rely=0.09, relwidth=0.13, relheight=0.15)
    dos1 = button2=Button(ventana,text='2',command=core.dos,bg="#FFFFFF")
    button2.place(relx=0.28, rely=0.09, relwidth=0.13, relheight=0.15)
    uno1 = button1=Button(ventana,text='1',command=core.una,bg="#FFFFFF")
    button1.place(relx=0.12, rely=0.09, relwidth=0.13, relheight=0.15)
    botones = [button1,button2,button3,button4,button5,button6,button7,button8,button9,button10,button11,button12,button13,button14,button15,button16,button17,button18,button19,button20,button21,button22,button23,button24,button25]
    ventana2.mainloop()
    ventana.mainloop()

El programa memoriza los patrones,realiza unas comparaciones bucleadas de la memoria con la entrada,calcula el peso,si es negativo no pasa y si es positivo pasa,pero este es comprobado por sistema de candidatos a elegir,a la vez este pasa por una comparación de una especie de un ajuste de peso de exactitud aparte de la neurona y elige el patrón mas acertado,esto lo hice para hacer mas exacto el resultado,contando con un valor minimo y maximo humano,es como un ajuste especial,pero no quita nada de lo fundamental.

La memoria del script es guardada por el modulo cPickle en un archivo llamado memoria.mem y la interfaz es manejada por Tkinter

Autor: netixzen

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *