Reporte Final

¿Qué se tenía en medio curso?

- Una neurona simple que recibía entradas binarias y agregaba pesos aleatorios. Posteriormente se realizaba la suma del producto de los pesos con las entradas y el resultado se compara con la salida deseada, si éstas no coincidían se hacia un cambio en el vector de pesos.

¿Qué se modifico y/o agrego para el reporte final?

- Método del gradiente

- Regla delta

- Back_propagation

- Red multicapa

Repositorio: https://github.com/jetsky0/projectvoteredes

Reporte.

Red multicapa (repositorio: neurona_multicapa.py)

Para este reporte, el objetivo era primero que nada hacer que la red neuronal fuera multicapa ¿por qué?, en una red monocapa solo pueden resolverse problemas linealmente separables, en cambio en casos en que se requiera separar clases y se necesiten por lo menos dos líneas para separarlas, debe utilizarse una red multicapa.

Un ejemplo de esto son las funciones lógicas.

AND y OR son funciones linealmente separables:

En cambio, la función XOR no puede ser aprendida por una red monocapa

Para realizar la red multicapa, se utiliza el método del gradiente. Este método es utilizado para minimizar la diferencia entre la salida deseada y la obtenida de la neurona. El método del gradiente se aplica en una función que mide el error  de clasificación de una red neuronal.

La fórmula es la siguiente (en esta fórmula se utiliza el sigmoidal que es igual a la tangente hiperbólica de x):

Donde:

Después de esto se utiliza la regla delta, para entrenar un patrón a la vez.

En este caso, como podemos ver se utiliza la derivada de la sigmoidal y se sigue haciendo la diferencia entre la salida esperada y la obtenida.

Con el algoritmo Back propagation, se puede definir el error total cometido por la red como la suma de los cuadrados de los errores cometidos. El objetivo es minimizar este error utilizando iteraciones para entrenar a redes multicapa.

¿Qué hace este algoritmo? 

- Calcula el error en la salida para cada patrón 

- Ajusta los pesos en la capa de salida para reducir el error. 

- Propaga los errores a la capa de entrada, ajustando los pesos de las capas ocultas, repite este paso de forma iterativa 

Características de Back propagation 

- El algoritmo busca el mínimo de la función error a partir de patrones de entrenamiento 

- Precisa que la función de activación sea diferenciable .

- Entrena, modificando los pesos de la red 

- Los pesos son modificados hacia la dirección descendente de la función error

En el programa que realicé se realiza todo lo anterior. Utilicé las funciones lógicas que mencionaba anteriormente para realizar pruebas de la red neuronal. Implemente XOR para comprobar que la red si funcionaba correctamente.

Implementé también una función sen(x) y trafique los resultados de una función sen(x) normal, y una función sen(x) aproximada con la red neuronal multicapa. 

Los resultados se muestran a continuación:

Se puede ver en la imagen, como la red aprende estas funciones lógicas y trigonométricas. En la imagen se observa cuales son las salidas obtenidas y los valores esperados, y se puede ver que es muy poca la diferencia. 

En la gráfica se observa más claramente, en color Rojo se observa la función aprendida por la red neuronal de sen(x), y en color azul la función real de sen(x).

La idea del proyecto, es que la neurona pueda leer las entradas de las huellas digitales y ser capaz de identificar la huella de una persona y así poder adecuar esto a nuestro proyecto integrador de la página de votaciones.

Referencias:

http://elisa.dyndns-web.com/~elisa/teaching/sys/neural/capas.pdf

Libro: An Introduction to Neural Networks, Kevin Gurney.

Reporte de avance medio curso

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.

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.

#!/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

Screenshots

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

Aplicación de una red neuronal

En la actualidad, hay grandes amenazas en el correo electrónico como virus, troyanos, gusanos y el flujo de mensajes no solicitados conocidos como Spam. El Spam se utiliza para anunciar productos y servicios de calidad dudosa. En un estudio de Microsoft Network y America Online, Inc. se reportó un total diario de 2.4 millones de Spam en e-mails entrantes. 

El aprendizaje automático es una base de investigación para la inteligencia artificial. El modelo de aprendizaje conexionista (basado en redes neuronales), está inspirado en una simplificación del sistema neuronal biológico (cerebral). Una red neuronal artificial está conformada por elementos de cálculo aritmético (neuronas) conectadas entre sí. 

Mi idea de proyecto consiste en detectar Spam en el correo electrónico por medio de redes neuronales, esto debido al excesivo Spam que existe en los correos electrónicos que nos causan muchas molestias al momento de abrir el correo y tener mensajes publicitarios no solicitados, cadenas de la suerte, virus, entre otras cosas que causan que revisar el correo sea una molestia.

Referencias:

http://biblioteca.espe.edu.ec/upload/Revista_ESPE_WF_MA_JR_Definitiva.pdf