Predicción de Enfermedad Cardíaca con Inteligencia Artificial

# FASE 2: Exploración básica del conjunto de datos
    # Número de registros y columnas
    print("DIMENSIONES DEL DATASET:")
    print(f"Registros (filas): {df.shape[0]}")
    print(f"Columnas (variables): {df.shape[1]}\n")

    # Tipos de datos por columna
    print("TIPOS DE DATOS DE CADA COLUMNA:")
    print(df.dtypes)
    print()

    # Clasificación de variables: numéricas vs categóricas
    print("CLASIFICACIÓN DE VARIABLES (Numéricas vs Categóricas):")
    numericas = df.select_dtypes(include=['number']).columns.tolist()
    categoricas = df.select_dtypes(exclude=['number']).columns.tolist()
    print(f"Variables numéricas ({len(numericas)}): {numericas}")
    print(f"Variables categóricas ({len(categoricas)}): {categoricas}\n")

    # Valores nulos por columna
    print("VALORES NULOS POR COLUMNA:")
    nulos = df.isnull().sum()
    print(nulos.to_string())

# FASE 3: Exploración más a fondo del conjunto de datos
    import seaborn as sns
    import matplotlib.pyplot as plt

    # 1. Estadísticas descriptivas de variables numéricas
    print("ESTADÍSTICAS DESCRIPTIVAS (Variables Numéricas):")
    print(df.describe())

    # 2. Distribución de la variable objetivo 'HeartDisease'
    print("\nDISTRIBUCIÓN DE LA VARIABLE OBJETIVO (HeartDisease):")
    print(df['HeartDisease'].value_counts())
    print("\nDISTRIBUCIÓN PORCENTUAL:")
    print(df['HeartDisease'].value_counts(normalize=True).map("{:.2%}".format))

    # 3. Gráfico de barras: distribución de clases
    plt.figure(figsize=(6,4))
    sns.countplot(x='HeartDisease', data=df, palette='Set2')
    plt.title('Distribución de Clases (HeartDisease)')
    plt.xlabel('Clase (0 = No Enfermo, 1 = Enfermo)')
    plt.ylabel('Frecuencia')
    plt.show()

# FASE 4: Preprocesamiento y división del conjunto de datos
    import numpy as np
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import OneHotEncoder, StandardScaler
    from sklearn.compose import ColumnTransformer

    # 1. Separar 5 registros aleatorios para pronóstico futuro
    df_sample = df.sample(n=5, random_state=42)
    df_rest = df.drop(df_sample.index).reset_index(drop=True)

    # 2. Identificar columnas numéricas y categóricas
    X = df_rest.drop(columns=['HeartDisease'])  # características
    y = df_rest['HeartDisease']                 # variable objetivo

    numeric_features = X.select_dtypes(include=['number']).columns.tolist()
    categorical_features = X.select_dtypes(exclude=['number']).columns.tolist()

    # 3. Definir transformaciones para preprocesamiento
    preprocessor = ColumnTransformer(
        transformers=[
            ('num', StandardScaler(), numeric_features),
            ('cat', OneHotEncoder(handle_unknown='ignore', drop='first'), categorical_features)
        ])

    # 4. Aplicar transformaciones y dividir datasets
    X_processed = preprocessor.fit_transform(X)
    X_train, X_test, y_train, y_test = train_test_split(
        X_processed, y, test_size=0.2, random_state=42, stratify=y
    )

# FASE 5: Entrenamiento y evaluación de modelos con hiperparámetros por defecto
    from sklearn.linear_model import LogisticRegression
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, AdaBoostClassifier
    from sklearn.svm import SVC
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.naive_bayes import GaussianNB
    from xgboost import XGBClassifier
    from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

    # Definición de modelos
    modelos = [
        ("Decision Tree", DecisionTreeClassifier(random_state=42)),
        ("AdaBoost", AdaBoostClassifier(random_state=42)),
        ("Gradient Boosting", GradientBoostingClassifier(random_state=42)),
        ("Random Forest", RandomForestClassifier(random_state=42)),
        ("SVM", SVC(random_state=42, probability=True)),
        ("Gaussian Naive Bayes", GaussianNB()),
        ("Logistic Regression", LogisticRegression(max_iter=1000, random_state=42)),
        ("K Neighbors", KNeighborsClassifier()),
        ("XGBoost", XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=42))
    ]

    # Entrenar y evaluar modelos
    resultados = []
    for nombre, modelo in modelos:
        modelo.fit(X_train, y_train)
        y_pred = modelo.predict(X_test)
        
        # Calcular métricas
        accuracy = accuracy_score(y_test, y_pred)
        precision = precision_score(y_test, y_pred)
        recall = recall_score(y_test, y_pred)
        f1 = f1_score(y_test, y_pred)
        
        resultados.append({
            "Modelo": nombre,
            "Accuracy": accuracy,
            "Precision": precision,
            "Recall": recall,
            "F1-Score": f1
        })

# FASE 6: Entrenamiento y evaluación con ajuste de hiperparámetros
    from sklearn.model_selection import GridSearchCV

    # Definición de modelos con espacios de búsqueda
    modelos_con_grid = [
        ("Random Forest", RandomForestClassifier(random_state=42), {
            'n_estimators': [50, 100, 150],
            'max_depth': [None, 5, 10],
            'min_samples_split': [2, 4],
            'min_samples_leaf': [1, 2],
            'bootstrap': [True, False]
        }),
        ("SVM", SVC(random_state=42, probability=True), {
            'C': [0.1, 1, 10],
            'kernel': ['linear', 'rbf'],
            'gamma': ['scale', 'auto']
        }),
        ("XGBoost", XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=42), {
            'n_estimators': [50, 100, 150],
            'learning_rate': [0.01, 0.1, 0.2],
            'max_depth': [3, 5],
            'min_child_weight': [1, 3, 5]
        })
    ]

    # Optimizar hiperparámetros
    for nombre, modelo, param_grid in modelos_con_grid:
        grid_search = GridSearchCV(
            estimator=modelo, 
            param_grid=param_grid, 
            cv=5, 
            scoring='f1', 
            n_jobs=-1
        )
        grid_search.fit(X_train, y_train)
        print(f"Mejores parámetros para {nombre}: {grid_search.best_params_}")

# FASE 7: Predicciones con los tres mejores modelos identificados
    from sklearn.neighbors import KNeighborsClassifier
    from xgboost import XGBClassifier
    from sklearn.ensemble import RandomForestClassifier

    # Entrenar modelos optimizados
    knn = KNeighborsClassifier(n_neighbors=10, p=1, weights='distance')
    xgb = XGBClassifier(learning_rate=0.1, max_depth=3, min_child_weight=3, 
                        n_estimators=50, subsample=1.0, use_label_encoder=False, 
                        eval_metric='logloss')
    rf = RandomForestClassifier(bootstrap=True, max_depth=5, min_samples_leaf=1, 
                            min_samples_split=2, n_estimators=50, random_state=42)

    # Entrenar con todo el conjunto de entrenamiento
    knn.fit(X_train, y_train)
    xgb.fit(X_train, y_train)
    rf.fit(X_train, y_train)

    # Realizar predicciones en datos reservados
    predicciones = []
    for modelo, nombre in zip([knn, xgb, rf], ['KNN', 'XGBoost', 'Random Forest']):
        y_pred = modelo.predict(X_sample_processed)
        y_proba = modelo.predict_proba(X_sample_processed)[:, 1]
        
        for i, (pred, proba) in enumerate(zip(y_pred, y_proba)):
            predicciones.append({
                "Modelo": nombre,
                "Registro": i + 1,
                "Predicción": "Enfermo (1)" if pred == 1 else "No enfermo (0)",
                "Probabilidad": f"{proba:.2%}"
            })

    # Mostrar resultados
    df_predicciones = pd.DataFrame(predicciones)
    print("PREDICCIONES EN LOS 5 REGISTROS RESERVADOS:")
    print(df_predicciones)