#COMPUERTA NOT

#Dataset: Entradas
X = np.array([[0],
              [0],
              [0],
              [1],
              [1],
              [1]])
                
#Salidas reales -> Aprendizaje Supervisado

y = np.array([[1],
          [1],
	      [1],
          [0],
          [0],    
          [0]])

X

#Datasets:
 
#COMPUERTA AND DE 2 ENTRADAS: cuando todas las entradas son 1, la salida es 1. Se agregan más filas (observaciones) para que
# la red aprenda mejor
    
#Dataset: Entradas
X = np.array([[0,0],
              [0,1],
              [1,0],
              [1,1]])
                
#Salidas reales -> Aprendizaje Supervisado

y = np.array([[0],
          [1],
	      [1],
          [1]])

X

# Construcción

#Como paso opcional, definimos una seed (semilla), para tener los mismo resultados, e inicializamos de forma aleatoria los pesos.
#La primera matriz de pesos tiene que ser de un tamaño fijo, en este caso (2,3) porque tenemos 2 valores de entrada 
#(es decir, 2 variables o características) y la siguiente capa tiene 3, entonces la salida tiene que tener la misma cantidad 
#de entradas que tiene la siguiente capa.

np.random.seed(1)

#syn0=np.array([[0.1,0.3,0.5],
#               [0.2,0.4,0.6]])
#syn1=np.array([[0.7],
#               [0.9],
#               [0.11]])

syn0 = np.random.random((3,16))
syn1 = np.random.random((16,1))

print('********** ENTRADAS')
print(X)
print('********** PESOS PARA CAPA DE ENTRADA')
print(syn0)
print('********** PESOS PARA CAPA DE SALIDA')
print(syn1)

#Entrenamiento

for j in range(100000):#cantidad de epochs (un epoch es una pasada de forwarding y backpropagation)
    
    #1. Forward Propagation: 
    #producto punto de nuestros datos por nuestros pesos (Suma Ponderada) y lo pasamos por nuestra función de activación.
    #Y para la siguiente capa multiplicamos los valores de la capa anterior y nuestra capa de pesos de la segunda capa. 
    #A esto nos referimos a que están cada una de las neuronas de la capa anterior conectadas con las neuronas 
    #de la capa siguiente.

    l0 = X
    #print('********** X')
    #print(l0)
    l1 = sigmoid(np.dot(l0,syn0)) #np.dot(l0,syn0) es z  
    #print('********** Salidas de capa 1')
    #print(l1)
    l2 = sigmoid(np.dot(l1,syn1)) #Estas son las predicciones
    #print('********** Salidas de capa 2 (salida)')
    #print(l2)
    
    #2. Calculo del Error: entre predicciones actuales y reales para determinar la Función de Pérdida
    l2_error = y - l2
    #print('********** Errores en capa de salida')
    #print(l2_error)     
    
    #Algoritmo de Descenso de Gradiente: la pendiente (la tasa de cambio) se calcula multiplicando nuestra pérdida actual 
    #con la derivada de nuestras predicciones actuales, de esta manera vamos a saber para que dirección ajustar los pesos.
    
    #Cálculo de gradiente en la capa de salida  
    l2_delta = l2_error*derivada(l2) #es la pendiente (direcciones hacia donde mover pesos). 
    #n (tasa de aprendizaje) es 1. l2 son las predicciones actuales, es decir, las entradas X de la capa actual.
    #print('********** Gradiente en capa de salida')
    #print(l2_delta)
    
    #3. Backpropagation: propagar el error hacia atrás -> "la dirección hacia donde moveremos los pesos de la ultima capa"
    
    #multiplicar la pendiente "l2_delta" por la transpuesta de los pesos de la capa anterior "syn1.T", de este modo 
    #propagaremos el error hacia atrás, y de esta manera la capa anterior "l1" calculará la dirección "l1_delta" hacia 
    #donde debe mover los pesos "syn1" y "syn0".
    
    #Cálculo de gradiente en la capa intermedia 
    l1_error = l2_delta.dot(syn1.T)
    #print('********** Errores en capa 1')
    #print(l1_error)
    l1_delta = l1_error * derivada(l1)
    #print('********** Gradiente en capa 1')
    #print(l1_delta)
    
    #Finalmente, ajustamos el valor de nuestros pesos, multiplicando la transpuesta de la capa por sus respectivas 
    #optimizaciones, o direcciones hacia donde actualizar los pesos, y esto se suma a nuestros pesos actuales, 
    #actualizando las dos capas a la vez.
    
    syn1 += l1.T.dot(l2_delta)
    syn0 += l0.T.dot(l1_delta)

print('********** Pesos de capa 1')
print(syn0)
print('********** Pesos de capa 2 (salida)')
print(syn1)
print('********** Predicciones')
print(l2)

#Se presenta las entradas, los valores reales y predicciones
#Se forma un dataframe con X
df = pd.DataFrame(X, columns = ['X1','X2','X3','X4'])
df.head()
y_pred = (l2 >= 0.5).astype("int32")
y_pred = y_pred.flatten()# de 2D a 1D
y_real=y.flatten()
#Se forma un dataframe con los valores reales y predicciones
dataframeSalida=pd.DataFrame({'real':y_real, 'predicción': y_pred})
dataframeSalida.head()
#Se concatena los dataframes de X y los valores reales y de predicción, esto con respecto al eje 1 (columnas)
df=pd.concat([df, dataframeSalida], axis=1)
df.head(16)

#Modelo secuencial quiere decir que agregaremos capas y se conectarán de manera secuencial.
import keras
from keras.layers import Dense
from keras.models import Sequential
from keras.models import model_from_json
#json:  {l1:'8',l2:'1'}
from sklearn.model_selection import train_test_split
from keras.models import load_model
print('Librerías importadas')

#DATASET PARA XOR
#XOR: tiene un uno (“1”) en su salida cuando la suma de los unos “1” en las entradas es igual a un número impar.
#Ref: http://tecdig2013g7.blogspot.com/2013/03/http2bpblogspotcom-dlcdju.html

#Dataset: Entradas
X = np.array([[0,0,0,0],
            [0,0,0,1],
            [0,0,1,0],
            [0,0,1,1],
            [0,1,0,0],
            [0,1,0,1],
            [0,1,1,0],
            [0,1,1,1],
            [1,0,0,0],
            [1,0,0,1],
            [1,0,1,0],
            [1,0,1,1],
            [1,1,0,0],
            [1,1,0,1],
            [1,1,1,0],
            [1,1,1,1],
            [0,0,0,0],
            [0,0,0,1],
            [0,0,1,0],
            [0,0,1,1],
            [0,1,0,0],
            [0,1,0,1],
            [0,1,1,0],
            [0,1,1,1],
            [1,0,0,0],
            [1,0,0,1],
            [1,0,1,0],
            [1,0,1,1],
            [1,1,0,0],
            [1,1,0,1],
            [1,1,1,0],
            [1,1,1,1]])
                
#Salidas reales -> Aprendizaje Supervisado
y = np.array([[0],
	      [1],
	      [1],
	      [0],
	      [1],
          [0],
	      [0],
          [1],
	      [1],
          [0],
	      [0],
          [1],
	      [0],
          [1],
	      [1],
          [0],
          [0],
	      [1],
	      [1],
	      [0],
	      [1],
          [0],
	      [0],
          [1],
	      [1],
          [0],
	      [0],
          [1],
	      [0],
          [1],
	      [1],
          [0]])
print('Dataset cargado')

#X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.5, random_state=42)
punto=int(X.shape[0]/2)
print(punto)
X_train=X[:punto]
X_test=X[punto:]
y_train=y[:punto]
y_test=y[punto:]
y_train

def guardarRNN(model,nombreArchivo):
    print("Guardando Red Neuronal en Archivo")  
    model.save(nombreArchivo+'.h5')
    print("Red Neuronal Grabada en Archivo")   
    
def cargarRNN(nombreArchivo):
    model = load_model(nombreArchivo+'.h5')    
    print("Red Neuronal Cargada desde Archivo") 
    return model
print('Funciones definidas')

#Construcción del Modelo o Arquitectura de Redes Neoronales
model = Sequential()

#La primera capa Dense recibe el numero de variables, que es la segunda dimensión de la matriz X, esto es X_train.shape[1]
#La primera capa tiene 3 neuronas. La función de activación es la función sigmoide.
model.add(Dense(10, input_shape=(X_train.shape[1],), activation='sigmoid'))#relu

#La capa de salida tiene 1 neurona. La capa de salida debe tener la misma dimensión como de cantidad de salidas queremos,
#por ejemplo, en este caso la salida solo requiere 0 o 1. La función de activación es sigmoide para mostrar como probabilidad.
model.add(Dense(1, activation='sigmoid'))

#Como tenemos dos posibles salidas "0 o 1", vamos a escoger que el error lo trate como una clasificación binaria, 
#el optimizador será nuestra función derivada que nos ayudará a determinar hacia donde mover los pesos.
model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['acc']) #rmsprop #ADADELTA: An Adaptive Learning Rate Method

#imprimir arquitectura de la red
model.summary()

#Visualización de accuracy
import matplotlib.pyplot as plt
print(history.history.keys())
plt.plot(history.history['loss'])
#plt.plot(history.history['val_loss'])
plt.title('Model loss')
plt.ylabel('Loss')
plt.xlabel('Epochs')
plt.legend(['Entrenamiento'], loc='upper left')
#plt.legend(['Entrenamiento', 'Validación'], loc='upper left')
plt.show()

#Cargar pesos y la arquitectura
model2=cargarRNN(nombreArchivoRedNeuronal) 

model2.compile(loss='binary_crossentropy', optimizer='adadelta', metrics=['acc']) #ADADELTA: An Adaptive Learning Rate Method
score = model2.evaluate(X_train, y_train, verbose=0)
print('Resultado en Train:')
print("%s: %.2f%%" % (model2.metrics_names[1], score[1]*100))

#Fase de Testing
print('Resultado en Test:')
score = model2.evaluate(X_test, y_test, verbose=0)
print("%s: %.2f%%" % (model2.metrics_names[1], score[1]*100))

import pandas as pd
np.set_printoptions(formatter={'float': lambda X: "{0:0.4f}".format(X)})
#nuevo_X=[[1,1,0,0]]
nuevo_X=X_test
predicciones=model2.predict(nuevo_X)
print(predicciones)
y_pred = (model2.predict(nuevo_X) >= 0.5).astype("int32")
y_pred = y_pred.flatten()# de 2D a 1D
y_test1D=y_test.flatten()
dataframeFinal=pd.DataFrame({'real':y_test1D, 'predicción': y_pred})
dataframeFinal.head(16)

def predecir(nuevo_X):
    y_pred = (model2.predict(nuevo_X) >= 0.5).astype("int32")
    y_pred = y_pred.flatten()# de 2D a 1D
    return y_pred
nuevo_X=[[1,1,1,0]]
prediccion=predecir(nuevo_X)
print(prediccion)