import tarfile
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Dropout, Flatten
import matplotlib.pyplot as plt
print('importadas')

#RGB: rojo, verde, azul

#Librería para visualizar la imagen
import numpy as np
import matplotlib.pyplot as plt

#Fijamos la semilla del generador de valores aleatorios
np.random.seed(42)

#256 indica que se crean valores entre 0 y 255
A = np.random.randint(256, size=(6,6,3))

#Visualizamos el tensor A
plt.imshow(A)

#print(A)
#print(type(A))

# Se descomprime el archivo
!tar xzvf cifar-10-python.tar.gz

import pickle

# Función para indicar el nombre de las categorías
def _load_label_names():
    """
    Load the label names from file
    """
    return ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']

# Función para cargar cada batch de imágenes
def load_cfar10_batch(cifar10_dataset_folder_path, batch_id):
    """
    Load a batch of the dataset
    """
    with open(cifar10_dataset_folder_path + '/data_batch_' + str(batch_id), mode='rb') as file:
        batch = pickle.load(file, encoding='latin1')
    
    #cada batch 10000 imágenes, cada imagen de 32x32x3
    features = batch['data'].reshape((len(batch['data']), 3, 32, 32)).transpose(0, 2, 3, 1) 
    labels = batch['labels']

    return features, labels

# Función para visualizar una imagen de un batch específico del dataset y presentar sus caracerísticas más relevantes
def display_stats(cifar10_dataset_folder_path, batch_id, sample_id):
    """
    Display Stats of the the dataset
    """
    batch_ids = list(range(1, 6))

    if batch_id not in batch_ids:
        print('Batch Id out of Range. Possible Batch Ids: {}'.format(batch_ids))
        return None

    features, labels = load_cfar10_batch(cifar10_dataset_folder_path, batch_id)

    if not (0 <= sample_id < len(features)):
        print('{} samples in batch {}.  {} is out of range.'.format(len(features), batch_id, sample_id))
        return None

    print('\nEstadísticas del batch {}:'.format(batch_id))
    print('Samples (cantidad de imágenes): {}'.format(len(features)))
    print('Cantidad de Etiquetas: {}'.format(dict(zip(*np.unique(labels, return_counts=True)))))
    print('Primeras 20 Etiquetas: {}'.format(labels[:20]))

    sample_image = features[sample_id]
    sample_label = labels[sample_id]
    label_names = _load_label_names()

    print('\nImagen {}:'.format(sample_id))
    print('Imagen - Valor Min: {} Valor Max: {}'.format(sample_image.min(), sample_image.max()))
    print('Imagen - Shape: {}'.format(sample_image.shape))
    print('Etiqueta - Etiqueta Id: {} Nombre: {}'.format(sample_label, label_names[sample_label]))
    #plt.axis('off')
    plt.imshow(sample_image)

batch_id = 1
sample_id = 9999
cifar10_dataset_folder_path='cifar-10-batches-py'
display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

#Para cargar el Dataset desde el arhivo local
(X_train, y_train), (X_test, y_test) = load_data()
print('\n********** Dataset cargado con X y Y')

import matplotlib.pyplot as plt
from collections import Counter
Y=y_train.flatten().tolist()
Y.extend(y_test.flatten().tolist())

# Utiliza Counter para contar las frecuencias de los elementos en la lista
frecuencias = Counter(Y)

# Separa las claves (elementos) y los valores (frecuencias) en listas separadas
elementos = list(frecuencias.keys())
frecuencias = list(frecuencias.values())

# Crea un gráfico de barras
plt.bar(elementos, frecuencias)

# Etiquetas y título
plt.xlabel('Categorías')
plt.ylabel('Frecuencia')
plt.title('Gráfico de Frecuencia')

# Establece las etiquetas del eje X
plt.xticks(elementos)

# Muestra el gráfico
plt.show()

# Normalizamos tanto X_train como X_test, en este caso de forma sencilla porque los valores de los pixeles van de 0 a 255. 
x_train = X_train/255
x_test = X_test/255
print("********* Normalización lista")

#Ejemplo para verificar
print('x:',X_test[9999,1,1,1])
print("""x':""",x_test[9999,1,1,1])

# Para verificar se presenta la estructura de una imagen
x_train.shape[1:]

#Fase de training

#procesamos las imágenes en lotes de 256 (para no cargar las 50000 imágenes de golpe) y 
#hacemos que la red recorra la fase de entrenamiento (epochs) 100 veces.
size_batch = 256
epocas = 6
history = model.fit(x_train, y_train, batch_size= size_batch, epochs=epocas, verbose=1)
#en 50 epochs aproximadamente: loss: 0.4032 - accuracy: 0.8588

#Fase de Testing
resultadoscnn = model.evaluate(x_test, y_test)

error_rate_cnn=resultadoscnn[0]
print('loss:',error_rate_cnn)
acc_cnn=resultadoscnn[1]
print('acc:',acc_cnn)
#con más epochs y 10000 imagenes en test. Aprox: loss: 0.5350 - accuracy: 0.8277

#Predicciones con el conjunto de Test
import pandas as pd
y_pred = model.predict(x_test)
#argmax identifica el valor máximo para determinar la categoría
y_pred = np.argmax(y_pred, axis=-1) 
y_pred = y_pred.flatten()
y_test2 = y_test.flatten()
print(y_pred)
print(y_test2)
dataframeFinal=pd.DataFrame({'real':y_test2, 'predicción': y_pred})
np.set_printoptions(formatter={'float': lambda X: "{0:0.0f}".format(X)})
dataframeFinal.head(10)

# Se evalúa el modelo con otras medidas de calidad y se presenta la matriz de confusión
from sklearn.metrics import confusion_matrix
import seaborn as sns
from sklearn import metrics  
from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
from matplotlib import*
from matplotlib.cm import register_cmap
import matplotlib.pyplot as plt 

MAE=metrics.mean_absolute_error(y_test2, y_pred)
MSE=metrics.mean_squared_error(y_test2, y_pred)
RMSE=np.sqrt(metrics.mean_squared_error(y_test2, y_pred))

MAE=str(round(MAE, 4))
MSE=str(round(MSE, 4))
RMSE=str(round(RMSE, 4))

print('Mean Absolute Error (MAE):', MAE)  
print('Mean Squared Error (MSE):', MSE)  
print('Root Mean Squared Error (RMSE):', RMSE) 

accuracyModeloBase=str(accuracy_score(y_test2,y_pred))
print('Accuracy: ' + accuracyModeloBase) 

precision=precision_score(y_test2,y_pred, average='weighted')#average one of [None, 'micro', 'macro', 'weighted']
precision=str(round(precision, 4))
print('Precision: ',precision)

recall=recall_score(y_test2,y_pred, average='weighted')
recall=str(round(recall, 4))
print('Recall: ',recall)

f1=f1_score(y_test2,y_pred, average='weighted')
f1=str(round(f1, 4))
print('F1:',f1)

print('Matriz de confusión:')
print(confusion_matrix(y_test2,y_pred))  

plt.figure(figsize=(15,10))
fx=sns.heatmap(confusion_matrix(y_test2,y_pred), annot=True, fmt=".2f",cmap="GnBu")
fx.set_title('Confusion Matrix \n');
fx.set_xlabel('\n Valores de predicción\n')
fx.set_ylabel('Valores reales\n');
fx.xaxis.set_ticklabels(_load_label_names())
fx.yaxis.set_ticklabels(_load_label_names())
plt.show()

# Se presenta la calidad de clasificación por categoría y a nivel general
from sklearn.metrics import classification_report
print(classification_report(y_test2,y_pred))

import numpy
import matplotlib.pyplot as plt
from PIL import Image

label_names = _load_label_names()

print('Imagen:')
sample_id=9999
sample_image=X_test[sample_id]
print(sample_image.shape)
sample_label=y_test[sample_id][0]
print('Etiqueta real - Etiqueta Id: {} Nombre: {}'.format(sample_label, label_names[sample_label]))  
#print(sample_image.shape)
sample_imageTrans = sample_image.reshape(1, 32, 32, 3)

print('Predicciones:')
resultados = model.predict(sample_imageTrans)[0]
print(resultados)
maxElement = numpy.amax(resultados)
print('certeza: ', str(round(maxElement*100, 4))+'%')
result = numpy.where(resultados == numpy.amax(resultados))
print('Max :', maxElement)
#print('Returned tuple of arrays :', result)
print('Lista de indices de máximo elemento :', result[0][0])
index_sample_label=result[0][0]

print(label_names)
print('Etiqueta predicción: ', label_names[index_sample_label])

img=sample_image
plt.imshow(img)

#Guardar imagen
#plt.savefig('Imagenes/imagen1.png')

#data = numpy.random.random((100,100))
#Rescale to 0-255 and convert to uint8
#rescaled = (255.0 / data.max() * (data - data.min())).astype(np.uint8)

im = Image.fromarray(sample_image)
im.save('Imagenes/imagen2.png')

import numpy as np
from PIL import Image

print('Imagen:')
img = Image.open('Imagenes/imagen1.png').convert('RGB')
arr = np.array(img)
print(arr.shape)

arrTrans = arr.reshape(1, 32, 32, 3)

print('Predicciones:')
resultados = model.predict(arrTrans)[0]
print(resultados)
maxElement = numpy.amax(resultados)
print('certeza: ', str(round(maxElement*100, 4))+'%')
result = numpy.where(resultados == numpy.amax(resultados))
print('Max :', maxElement)
#print('Returned tuple of arrays :', result)
print('Lista de indices de máximo elemento :', result[0][0])
index_sample_label=result[0][0]

print(label_names)
print('Etiqueta predicción: ', label_names[index_sample_label])

sample_image = arrTrans.reshape(32, 32, 3)

img=sample_image
plt.imshow(img)

#Se puede partir del dataset anterior o cargar el dataset de keras:
#from tensorflow.keras.datasets import cifar10
#(X_train, y_train), (X_test, y_test) = cifar10.load_data()
#x_train = X_train/255
#x_test = X_test/255

#Para transformar X en estructura clásica de ML (2D) para aplicar técnicas como SVM, Redes Neuronales Densas, KNN, etc.
X_trainReshapeImageRow=x_train.reshape((x_train.shape[0],3072))
print(X_trainReshapeImageRow.shape)                 
X_testReshapeImageRow=x_test.reshape((x_test.shape[0],3072))
print(X_testReshapeImageRow.shape) 

# Función para visualizar y describir una imagen específica
def display_stats(sample_id):
    features, labels = X_trainReshapeImageRow, y_train
    sample_image = features[sample_id]
    sample_label = labels[sample_id][0]
    label_names = _load_label_names()
    print('\nImagen {}:'.format(sample_id))
    print('Imagen - Valor Min: {} Valor Max: {}'.format(sample_image.min(), sample_image.max()))
    print('Imagen - Shape: {}'.format(sample_image.shape))
    print('Etiqueta - Etiqueta Id: {} Nombre: {}'.format(sample_label, label_names[sample_label]))
    #plt.axis('off')
    imagen=sample_image.reshape(32, 32, 3)#.transpose(1, 2, 0)
    plt.imshow(imagen)
    cv.imwrite('imagen.jpg', imagen)
sample_id = 9999
display_stats(sample_id)

# Se desarrolla el modelo
modeloestandar = Sequential()
modeloestandar.add(Dense(32, input_dim=X_trainReshapeImageRow.shape[1], activation='relu'))
modeloestandar.add(Dense(32, activation='relu'))   
modeloestandar.add(Dense(64, activation='relu'))
modeloestandar.add(Dense(64, activation='relu'))
modeloestandar.add(Dense(64, activation='relu'))
modeloestandar.add(Dense(64, activation='relu'))
modeloestandar.add(Dense(512, activation='relu'))
modeloestandar.add(Dense(512, activation='relu'))
#en la última capa tiene que haber tantas neuronas como clases haya, en este caso 10
modeloestandar.add(Dense(10, activation='softmax'))

#compilamos el modelo
modeloestandar.compile(loss='sparse_categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

size_batch = 512
epocas = 20
history = modeloestandar.fit(X_trainReshapeImageRow, y_train, batch_size= size_batch, epochs=epocas, verbose=1)

resultadosRedEstandar=modeloestandar.evaluate(X_testReshapeImageRow, y_test)
error_rate_rnestandar=resultadosRedEstandar[0]
print('loss:',error_rate_rnestandar)
acc_rnestandar=resultadosRedEstandar[1]
print('acc:',acc_rnestandar)

tabla = pd.DataFrame(columns=('Método', 'Accuracy','Loss'))
tabla.loc[len(tabla)]=['Red Neuronal Estándar',acc_rnestandar,error_rate_rnestandar] 
tabla.loc[len(tabla)]=['CNN',acc_cnn,error_rate_cnn] 
tabla.head()