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

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


#Función lineal
def lineal(x):
    result = x
    return result

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

#Algoritmo Adeline
def algoritmoAdeline(entrada, tasaAprendizaje, errorAceptado):
    #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<=errorAceptado):
            break
        else:
            #Si hay error actualizamos los pesos con la regla del perceptrón

            #Obtenemos el error de un patrón dado
            entradaActual = entrada[patron,0:2]
            salidaDeseada = entrada[patron,2]
            salidaObtenida = neurona(entradaActual,pesos,theta)

            #Debido a que es una sola neurona tomamos el error de este patrón
            errorPatron = 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*errorPatron*entradaActual[j]

            theta = theta + tasaAprendizaje*errorPatron
            #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.1

#patron deseado
#Vamos a trabajar la función 2x + y
#entradas = np.array([[1,3,5],[2,1,5],[2,2,6],[1,1,3]])

#Funcion suma
entradas = np.array([[1,3,4],[2,1,3],[2,2,4],[1,1,2]])

#And normal
#entradas = np.array([[0,0,0],[0,1,0],[1,0,0],[1,1,1]])

#entradas = np.array([[-1,-1,-1],[-1,1,-1],[1,-1,-1],[1,1,1]])
#Iteraciones
iteraciones = 200

#Error aceptado
errorAceptado = 0.8

pesos, evolucionDelError,theta = algoritmoAdeline(entradas, tasaAprendizaje,errorAceptado)

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 adeline')
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()