import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
dataset = "heart.csv"
#df = pd.read_csv(dataset, names=['age','sex','cp','trestbps','chol','fbs','restecg','thalach','exang','oldpeak','slope','ca','thal','target'])
df = pd.read_csv(dataset)
#df = df.iloc[1:]
print(df.shape)
df.head(10)

# Se separa la variable objetivo (dependiente) de las variables independientes X
Y=df['target']
df=df.drop(['target'], axis=1)
print(df.shape)
df.head()

# Se estandariza a una escala única (media = 0 y varianza = 1) que es necesario para un mejor rendimiento
from sklearn.preprocessing import StandardScaler
x = df.values
# Se transforma las variables mediante estandarización
#X_std = MinMaxScaler(feature_range=(0, 1)).fit_transform(x)
X_std = StandardScaler().fit_transform(x)
#print(X_std)
n_samples=X_std.shape[0]
print("********** Cantidad de observaciones (samples):",n_samples)
n_features=X_std.shape[1]
print("********** Cantidad de variables (features):",n_features)
print("Se ha transformado los datos")

#Se calcula la matriz de covarianzas nxn, en este caso, 13x13 
mean_vec = np.mean(X_std, axis=0)
cov_mat = (X_std - mean_vec).T.dot((X_std - mean_vec)) / (X_std.shape[0]-1)
print('********** Matriz de covarianzas:')
print(cov_mat)

cov_mat = np.cov(X_std.T)
eig_vals, eig_vecs = np.linalg.eig(cov_mat)
print('********** Eigenvectors:')
print(eig_vecs)
print('********** Eigenvalues:')
print(eig_vals)
print('********** Varianza total:')
print(eig_vals.sum())

# Lista ordenada de eigenvalues (de mayor a menor)
eig_pairs = [(np.abs(eig_vals[i]), eig_vecs[:,i]) for i in range(len(eig_vals))]
#print(eig_pairs)
puntuados=sorted(eig_pairs, key=lambda x: (x[0], x[1]), reverse=True)
#print(puntuados)
print('Eigenvalues (varianzas) en orden descendente:')
for i in puntuados:
    print(i[0])
    #print(i[1])

num_components_max = min(n_samples, n_features)
print("*********** Máximo número de componentes:",num_components_max)

totalVar= eig_vals.sum()
print("*********** Varianza total (suma de eigenvalues):",totalVar)

# Aquí puedes ajustar la cantidad de componentes
num_components_seleccionados=4
print("*********** Número de componentes seleccionados:",num_components_seleccionados)
puntuadosSeleccionados=puntuados[:num_components_seleccionados]
eig_vals_seleccionados = []
eig_vecs_seleccionados = []
for i in puntuadosSeleccionados:
    #print(i[0])
    eig_vals_seleccionados.append(i[0])
    #print(i[0])
    eig_vecs_seleccionados.append(i[1])
#Transformar lista en matriz para las operaciones posteriores
eig_vecs_seleccionados = np.array(eig_vecs_seleccionados)
print(eig_vals_seleccionados)

#Obtener matriz reducida
principalComponents = np.dot(X_std,eig_vecs_seleccionados.T)
#Calcular el porcentaje de varianza de cada dimensión
explained_variance_ratio_=np.array([eig_vals_seleccionados[i]/totalVar for i in range(num_components_seleccionados)])
print('Porcentaje de varianza de cada dimension con respecto a la varianza total:')
print(explained_variance_ratio_.round(4))

a = range(num_components_seleccionados)
num_pc= a[::1]
principalDf = pd.DataFrame(data = principalComponents
             , columns = num_pc)
principalDf=round(principalDf, 2)
print('Componentes Principales:')
principalDf.head()

# Se aplica PCA de sklearn. Con fit_transform se ejecutan todos los pasos de PCA
from sklearn.decomposition import PCA
# Aquí puedes ajustar la cantidad de componentes seleccionados
num_components=9
pca = PCA(num_components)
principalComponents = pca.fit_transform(X_std)
# Se obtiene los eigenvalues
eigenvalues = pca.explained_variance_
print('Eigenvalues (varianzas) en orden descendente:')

for eigenvalue in eigenvalues:
    print(eigenvalue)
a = range(num_components)
num_pc= a[::1]

principalDf = pd.DataFrame(data = principalComponents
             , columns = num_pc)

principalDf=round(principalDf, 2)
print('Componentes Principales:')
principalDf.head()

#La varianza indica cuanta información tiene cada dimensión 
#pca.explained_variance_ratio_  indica la relación de la varianza de cada dimensión con respecto al total de la varianza
print('Varianza de cada dimensión con respecto a la varianza total:')
explained_variance_ratio_=pca.explained_variance_ratio_
for varianza in explained_variance_ratio_:
    print(varianza.round(4))

explained_variance_ratio_cumsum=explained_variance_ratio_.cumsum()
print("********** Varianza acumulada:",explained_variance_ratio_cumsum.round(3))
num_pc= num_components
a = range(1,num_pc+1)
num_pc= a[::1]
num_pc
#Visualización de varianza por componente y varianza acumulada
plt.plot(num_pc, explained_variance_ratio_, color='blue', linestyle='dashed', linewidth = 3, 
         marker='o', markerfacecolor='blue', markersize=5, label = 'varianza explicada')
plt.plot(num_pc, explained_variance_ratio_cumsum, color='orange', linestyle='dashed', linewidth = 3, 
         marker='o', markerfacecolor='blue', markersize=5, label = 'varianza explicada acumulativa')
plt.ylim((0,1.2))
plt.title('Varianza con '+str(num_components)+' componentes principales')
plt.xlabel('ID Componente Principal')
plt.ylabel('Varianza')
plt.legend(loc="upper right")
plt.show()

# Se contatena la matriz reducida con la variable objetivo Y
finalDf = pd.concat([principalDf, Y], axis = 1)
print(finalDf.shape)
finalDf.head()

#Visualización 2 dimensiones
import matplotlib.pyplot as plt
fig = plt.figure(figsize = (8,8))
ax = fig.add_subplot(1,1,1) 
ax.set_xlabel('Principal Component 1', fontsize = 15)
ax.set_ylabel('Principal Component 2', fontsize = 15)
ax.set_title('2 component PCA', fontsize = 20)
targetsNombre = ['presencia', 'ausencia']
targets = [0, 1]
colors = ['r', 'g', 'b']
for target, color in zip(targets,colors):
    indicesToKeep = finalDf['target'] == target
    ax.scatter(finalDf.loc[indicesToKeep, 0]
               , finalDf.loc[indicesToKeep, 1]
               , c = color
               , s = 50)
ax.legend(targetsNombre)
ax.grid()
plt.show()

# Visualización 3 dimensiones
from mpl_toolkits.mplot3d import axes3d
import matplotlib.pyplot as plt
fig = plt.figure(figsize = (8,8))
ax1 = fig.add_subplot(111, projection='3d')
ax1.set_xlabel('Componente Principal 1', fontsize=10)
ax1.set_ylabel('Componente Principal 2', fontsize=10)
ax1.set_zlabel('Componente Principal 3', fontsize=10)
ax1.set_title('PCA 3D',fontsize=15)
targetsNombre = ['presencia', 'ausencia']
targets = [0, 1]
colors=['blue','green','red']
for target, color in zip(targets,colors):
    indicesToKeep = finalDf['target'] == target
    ax1.scatter(finalDf.loc[indicesToKeep, 0]
               , finalDf.loc[indicesToKeep, 1]
               , finalDf.loc[indicesToKeep, 2]
               , c=color
               , s=50)
ax1.legend(targetsNombre)
ax1.grid()
plt.show()

from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor, KNeighborsClassifier
from sklearn import metrics 
from sklearn.metrics import confusion_matrix  
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 sklearn.preprocessing import OneHotEncoder, StandardScaler, OrdinalEncoder, MinMaxScaler
from sklearn.model_selection import cross_val_score

# Crear un DataFrame vacío con las columnas deseadas
columnas = ['MÉTODO','ACC']
# Definr el tipo de dato de cada columna
tipos_de_variable = [str, float]
# Crear un dataframe vacío, a este dataframe se agregarán fila a fila los resultados
dataResultados = pd.DataFrame(columns=columnas)

df = pd.read_csv(dataset)
Y=df['target']
df=df.drop(['target'], axis=1)

#Aquí puedes ajustar los parámetros del clasificador
numFolds = 5 # cantidad de experimentos o Folds (pliegues)
metrica = 'manhattan' # la medida de distancia
K = 25 # la cantidad de vecinos
num_componentes = 13 # lacantidad de componentes seleccionados

# Crea el Pipeline solamente con clasificacion
steps = [
    ('clasificadorKNN', KNeighborsClassifier(n_neighbors=K, metric=metrica))  # Establece n_neighbors aquí
]
pipeline1 = Pipeline(steps)

# Crea el Pipeline con estandarización, reducción y clasificación
steps = [
    ('estandarizacion', StandardScaler(with_mean=True,with_std=True)),  # Define tu preprocesamiento aquí
    ('clasificadorKNN', KNeighborsClassifier(n_neighbors=K, metric=metrica))  # Establece n_neighbors aquí
]
pipeline2 = Pipeline(steps)

# Crea el Pipeline con normalización, reducción y clasificación
steps = [
    ('normalizacion', MinMaxScaler(feature_range=(0, 1))),
    ('clasificadorKNN', KNeighborsClassifier(n_neighbors=K, metric=metrica))  # Establece n_neighbors aquí
]
pipeline3 = Pipeline(steps)

# Crea el Pipeline con normalización, reducción y clasificación
steps = [
    ('reduccion', PCA(n_components=num_componentes)), 
    ('clasificadorKNN', KNeighborsClassifier(n_neighbors=K, metric=metrica))  # Establece n_neighbors aquí
]
pipeline4 = Pipeline(steps)

# Crea el Pipeline con normalización, reducción y clasificación
steps = [
    ('estandarizacion', StandardScaler(with_mean=True,with_std=True)),  # Define tu preprocesamiento aquí
    ('reduccion', PCA(n_components=num_componentes)), 
    ('clasificadorKNN', KNeighborsClassifier(n_neighbors=K, metric=metrica))  # Establece n_neighbors aquí
]
pipeline5 = Pipeline(steps)

# Crea el Pipeline con normalización, reducción y clasificación
steps = [
    ('normalizacion', MinMaxScaler(feature_range=(0, 1))),
    ('reduccion', PCA(n_components=num_componentes)), 
    ('clasificadorKNN', KNeighborsClassifier(n_neighbors=K, metric=metrica))  # Establece n_neighbors aquí
]
pipeline6 = Pipeline(steps)

#cantidadPasos=len(pipe.steps)
#print(pipe.get_params().keys())

ACC=cross_val_score(pipeline1, df, Y, cv=numFolds, n_jobs=-1, error_score="raise").mean()
pasos = '-'.join([elemento[0] for elemento in pipeline1.steps[:]])
fila = pd.Series([pasos,ACC], index=columnas)
dataResultados = pd.concat([dataResultados, fila.to_frame().T], ignore_index=True)

ACC=cross_val_score(pipeline2, df, Y, cv=numFolds, n_jobs=-1, error_score="raise").mean()
pasos = '-'.join([elemento[0] for elemento in pipeline2.steps[:]])
fila = pd.Series([pasos,ACC], index=columnas)
dataResultados = pd.concat([dataResultados, fila.to_frame().T], ignore_index=True)

ACC=cross_val_score(pipeline3, df, Y, cv=numFolds, n_jobs=-1, error_score="raise").mean()
pasos = '-'.join([elemento[0] for elemento in pipeline3.steps[:]])
fila = pd.Series([pasos,ACC], index=columnas)
dataResultados = pd.concat([dataResultados, fila.to_frame().T], ignore_index=True)

ACC=cross_val_score(pipeline4, df, Y, cv=numFolds, n_jobs=-1, error_score="raise").mean()
pasos = '-'.join([elemento[0] for elemento in pipeline4.steps[:]])
fila = pd.Series([pasos,ACC], index=columnas)
dataResultados = pd.concat([dataResultados, fila.to_frame().T], ignore_index=True)

ACC=cross_val_score(pipeline5, df, Y, cv=numFolds, n_jobs=-1, error_score="raise").mean()
pasos = '-'.join([elemento[0] for elemento in pipeline5.steps[:]])
fila = pd.Series([pasos,ACC], index=columnas)
dataResultados = pd.concat([dataResultados, fila.to_frame().T], ignore_index=True)

ACC=cross_val_score(pipeline6, df, Y, cv=numFolds, n_jobs=-1, error_score="raise").mean()
pasos = '-'.join([elemento[0] for elemento in pipeline6.steps[:]])
fila = pd.Series([pasos,ACC], index=columnas)
dataResultados = pd.concat([dataResultados, fila.to_frame().T], ignore_index=True)

dataResultados.head(6)

#Con el mejor modelo se calcula las predicciones y se mide la calidad en detalle
pipe=pipeline5
X_train, X_test, y_train, y_test = train_test_split(df, Y, test_size = 0.2)#random_state = 0
pipe.fit(X_train, y_train)#modelNN__validation_split=0.1, modelNN__batch_size=10

y_pred = (pipe.predict(X_test) > 0.5).astype("int32")
y_pred=y_pred.flatten()# de 2D a 1D
dataframeFinal=pd.DataFrame({'real':y_test, 'predicción': y_pred})
np.set_printoptions(formatter={'float': lambda X: "{0:0.0f}".format(X)})
dataframeFinal.head(10)

accuracy, precision, recall, f1=medirCalidad(y_test, y_pred)