Durante la primera mitad del semestre junto con mi
compañero Adán implementamos una red neuronal que utilizaremos en nuestro
proyecto para reconocer huellas digitales.
Antes que nada, investigué cosas relacionadas con huellas
digitales, sus características y formas en las que se podían representar para
obtener una entrada de datos para la neurona.
A lo largo de este tiempo, estuve leyendo el libro de redes neuronales que nos recomendó la maestra, con esto y las presentaciones de la maestra logré entender como funciona una red neuronal.
A lo largo de este tiempo, estuve leyendo el libro de redes neuronales que nos recomendó la maestra, con esto y las presentaciones de la maestra logré entender como funciona una red neuronal.
Empecé con el desarrollo de la neurona en algunas clases,
con ayuda de mi compañero realizamos lo principal que era la entrada de datos y
la sumatoria de las entradas con sus pesos correspondientes para después
compararla con el umbral y obtener una salida. Después de que mi compañero
finalizó esto, yo me encargue de implementar la tasa de aprendizaje para la
neurona, para esto se le pedía al usuario la salida esperada, la cual se
utiliza después para compararla con la salida obtenida en la función de
activación y si estas son diferentes se realiza una modificación en los pesos.
Implementé la ecuación con la tasa de aprendizaje para modificar la línea de
separación de las clases.
Esta implementado para que se modifique este vector las
veces que sea necesario para que pueda separar las clases adecuadamente. Al
final tiene un contador que te dice cuantas veces falló y se tuvieron que
modificar los pesos.
En la parte de la presentación grupal aporté algunas
ideas así como también realicé el diagrama de arquitectura de la red neuronal.
También estuve realizando pruebas para mostrar el resultado de la neurona
gráficamente, pero tuve unos pequeños problemas que solucionaré para mostrarlo
en la siguiente entrega. También estoy investigando sobre la red multicapa y el
uso de más neuronas en nuestra red, actualmente estoy tratando de acoplar las entradas
de datos binarios que se generaron de las imágenes que se encuentran en la base
de datos para poder obtener una resultado real.
Código.
Version 2. http://www.mediafire.com/?25edyd5tdznr38p
Version 4. http://www.mediafire.com/?sduxz5qa7myqda7
Código.
#!/usr/bin/python
import random
x=[]
w=[] #pesos
wn=[] #pesos nuevos
wi=[] #pesos nuevos insertados
alpha = 0.05
umbral = 0.5
t = 0
p = 0
res = 0
res2 = 0
suma = 0
mult = 0
i = 1
countErr=0
def inicio():
global n
n = input("Dame el numero de entradas ")
for i in range(n):
x.insert(i,random.uniform(0,2)) #generar cadena de entradas binarias aleatorias
w.insert(i,random.uniform(-1.0,1.0)) #generar cadenas de pesos random
x.append(-1) #agregar al vector de entradas un -1 al final
print '\nVector de elementos de entrada generado \n', x[:]
w.append(umbral) #agregar al vector de pesos el umbral al final
print '\nVector de elementos de pesos generado \n', w[:]
sumatoria() #brincar a la funcion sumatoria
return n
def sumatoria():
global suma
suma=0
res=0
res = x[i] * w[i] #sumatoria del producto de elementos de entrada por elmentos del peso
suma = suma + res #actualizar sumatoria
#t = raw_input("\nSalida Esperada (0 o 1): ") #pedir al usuario salida esperada
t = random.randint(0,1) #generar solucion esperada aleatoria entre 0 y 1
#t = int(t)
print '\nLa salida aleatoria deseada es \n', t
print '\nLa sumatoria de productos de entradas por pesos es:', suma #imprimir la sumatoria total del producto de entradas por pesos
comparacion(t,n) #brincar a la funcion comparacion
return t
def comparacion(t,n):
global countErr
if(suma>=umbral): #comparar suma con el umbral
p=1 #suma mayor o igual a 1, salida obtenida = 1
print '\nLa salida obtenida = 1'
else:
p=0 #de lo contrario, salida obtenida = 0
print '\nLa salida obtenida = 0'
i=1
if(t!=p): #si la salida esperada difiere de la salida producida, se realiza un cambio en el vector de pesos
countErr +=1
wn[:]=[]
for i in range(n+1):
mult = alpha*(t-p)*x[i] #agregamos la tasa de aprendizaje alpha para modificar los pesos
wi.insert(i,w[i] + mult)
wn.insert(i,wi[i]) #agregamos a un vector nuevo los nuevos pesos
wn.append(umbral) #agregamos el umbral al final del vector de pesos nuevo
w[:]=[]
for i in range(n+1):
w.insert(i,wn[i])
print '\nVector de elementos de pesos nuevos generado es \n', wn[:] #imprimimos el vector nuevo de pesos
sumatoria() #brincamos a la funcion sumatoria para volver a hacer calculas
else:
print 'La salida esperada fue diferente que la obtenida', countErr, 'veces'
return countErr, w[:]
def main():
global x,n,w,wn,wi,umbral
inicio()
main()
Version 2. http://www.mediafire.com/?25edyd5tdznr38p
Version 4. http://www.mediafire.com/?sduxz5qa7myqda7
Version 2.
Version 4.
Presentación.
Compañeros de equipo.
Daniel Martínez: Link a blog
Sergio Hernández: Link a blog
Adán Cuellar: Link a blog
