Perceptron

# encoding: utf-8
# Autor: Carlos Andres Delgado
# Algoritmo Perceptron

import numpy as np
import matplotlib.pyplot as plt
import math
import random as rnd

#Función signo
def signo(x):
        if(x>0):
                result = 1
        elif (x<0):
                result = -1
        else:
                result = 0

        return result


#Neurona
def neurona(entrada, pesos, theta):
    entradaNeta = np.dot(pesos,np.transpose(entrada))+theta
    salida = signo(entradaNeta)
    return salida

#Algoritmo Perceptron
def algoritmoPerceptron(entrada, iteraciones,tasaAprendizaje):
    #Error
    evolucionDelError = np.array([])

    #Generar pesos aleatorios entre -1 y 1
    pesos = 2*np.random.rand(2)-1
    theta = 2*rnd.random()-1
    #Iniciamos con el primer patron
    patron = 0

    #Obtenemos filas y columnas
    filas = entrada.shape[0]
    columnas = entrada.shape[1]

    #El primer criterio de parada es el número de iteraciones
    for it in range(0,iteraciones):
        error = 0
        #entrada.shape[0] número de datos en la primera dimensión (filas)
        #Probamos todas las entradas con los pesos
        for i in range(0, filas):
            entradaActual = entrada[i,0:2]
            salidaDeseada = entrada[i,2]
            salidaObtenida = neurona(entradaActual,pesos,theta)
            #Calculamos el error cuadrático medio
            error += math.pow(salidaDeseada - salidaObtenida, 2)

        error = error/2
        evolucionDelError = np.append(evolucionDelError,error)

        #El segundo criterio de parada es si alcanzamos un error = 0
        if(error==0):
            break
        else:
            #Si hay error actualizamos los pesos con la regla del perceptrón

            #Obtenemos la diferencia entre la salida esperada y un patron dado
            entradaActual = entrada[patron,0:2]
            salidaDeseada = entrada[patron,2]
            salidaObtenida = neurona(entradaActual,pesos,theta)
            diferencia = salidaDeseada - salidaObtenida

            #Se toma columnas-1, ya que la ultima columna es la salida
            for j in range(0,columnas-1):
                pesos[j] = pesos[j] + tasaAprendizaje*diferencia*entradaActual[j]

            theta = theta + tasaAprendizaje*diferencia
            #Ahora seguimos con el siguiente patrón de entrada
            patron=patron+1

        #Si todos los patrones han sido probados, volvemos a empezar
        if patron>=filas:
            patron = 0

    return pesos, evolucionDelError,theta

#Tasa de aprendizaje
tasaAprendizaje = 0.5

#patron deseado
entradas = np.array([[-1,-1,-1],[-1,1,-1],[1,-1,-1],[1,1,1]])

#Iteraciones
iteraciones = 200

pesos, evolucionDelError,theta = algoritmoPerceptron(entradas, iteraciones,tasaAprendizaje)

filas = entradas.shape[0]
columnas = entradas.shape[1]

#Probamos los pesos entrenados
for i in range(0, filas):
    entradaActual = entradas[i,0:2]
    salidaDeseada = entradas[i,2]
    salidaObtenida = neurona(entradaActual,pesos,theta)
    print("******************")
    print("Entrada",entradaActual)
    print("Salida Deseada",salidaDeseada)
    print("Salida Obtenida",salidaObtenida)

print("Pesos",pesos)
print("Error",evolucionDelError)
#Pintamos la evolución del error
figura = plt.figure()
plt.title(u'Error de entrenamiento perceptrón')
plt.xlabel('Iteraciones')
plt.ylabel(u'Error cuadrático medio')
plt.plot(range(1,evolucionDelError.shape[0]+1), evolucionDelError,'bo-')
plt.grid(True)
plt.xticks(range(1,evolucionDelError.shape[0]+1))
plt.show()