# 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



#Red neuronal
def redNeuronal(entrada, matrizPesos, theta):
    entradaNetaN1 = np.dot(matrizPesos[0,:],np.transpose(entrada))+theta[0]
    SalidaN1 = signo(entradaNetaN1)
    entradaNetaN2 = np.dot(matrizPesos[1,:],np.transpose(entrada))+theta[1]
    SalidaN2 = signo(entradaNetaN2)

    return np.array([SalidaN1, SalidaN2])

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

    #Generar pesos aleatorios entre -1 y 1
    pesos = 2*np.random.rand(2,2)-1
    theta = 2*np.random.rand(2)-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]
            salidaObtenida = redNeuronal(entradaActual,pesos,theta)
            #Calculamos el error cuadrático medio

            salidaDeseadaN1 = entrada[i,2]
            salidaDeseadaN2 = entrada[i,3]

            error += math.pow(salidaDeseadaN1 - salidaObtenida[0], 2)
            error += math.pow(salidaDeseadaN2 - salidaObtenida[1], 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]

            salidaObtenida = redNeuronal(entradaActual,pesos,theta)
            #Calculamos el error cuadrático medio

            salidaDeseadaN1 = entrada[patron,2]
            salidaDeseadaN2 = entrada[patron,3]

            diferenciaN1 = salidaDeseadaN1 - salidaObtenida[0]
            diferenciaN2 = salidaDeseadaN2 - salidaObtenida[1]

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

                pesos[1][j] = pesos[1][j] + tasaAprendizaje*diferenciaN2*entradaActual[j]

            theta[0] = theta[0] + tasaAprendizaje*diferenciaN1
            theta[1] = theta[1] + tasaAprendizaje*diferenciaN2
            #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.2

#patron deseado, primera N1: AND, N2, OR
entradas = np.array([[-1,-1,-1,-1],[-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]
    salidaDeseadaN1 = entradas[i,2]
    salidaDeseadaN2 = entradas[i,3]

    salidaObtenida = redNeuronal(entradaActual,pesos,theta)
    print("******************")
    print("Entrada",entradaActual)
    print("Salida Deseada ",np.array(entradas[i,2:4]))
    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()