Add application file

app.py

@@ -0,0 +1,140 @@
+# app.py - Módulo para src
+import streamlit as st
+from streamlit_option_menu import option_menu
+import streamlit_lottie as st_lottie
+import json
+import google.generativeai as genai
+from dotenv import load_dotenv
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Importaciones locales
+from datos.upload import show_upload
+from datos.prepare import show_prepare
+from models.train import show_train
+from models.test import show_test
+from models.unsupervised import show_unsupervised
+
+# Configuración inicial
+st.set_page_config(initial_sidebar_state="collapsed", page_title="Machine Learning", page_icon="🤖", layout="wide")
+load_dotenv()
+
+# Función para cargar el archivo Lottie
+def load_lottie_file(filepath: str):
+    try:
+        # Construir ruta absoluta
+        base_path = os.path.dirname(os.path.abspath(__file__))
+        full_path = os.path.join(base_path, 'assets', filepath)
+        
+        with open(full_path, 'r') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        st.error(f"Archivo Lottie no encontrado: {full_path}")
+        return None
+
+# Configuración del sidebar
+with st.sidebar:
+    # Cargar y mostrar el logo animado
+    try:
+        gemini_logo = load_lottie_file('gemini_logo.json')
+        if gemini_logo:
+            st_lottie.st_lottie(
+                gemini_logo, 
+                key='logo', 
+                height=50,
+                width=50,
+                loop=True,
+                quality="low"
+            )
+    except Exception as e:
+        st.error(f"Error al cargar el logo: {e}")
+    
+    # Sección de API Keys
+    st.markdown("### Configuración de APIs")
+    
+    # Gemini API
+    st.markdown('''
+        [Consigue tu API Key de Google AI Studio](https://aistudio.google.com/app/apikey)
+    ''')
+    genai_api_key = st.text_input(
+        "Gemini API Key",
+        type="password", 
+        placeholder="Ingresa tu API Key de Gemini",
+        key='gemini_api_key'
+    )
+
+    # Supabase API
+    st.markdown('''
+        [Consigue tus credenciales de Supabase](https://supabase.com/dashboard/project/_/settings/api)
+    ''')
+    supabase_url = st.text_input(
+        "Supabase URL",
+        type="password",
+        placeholder="Ingresa tu Supabase URL",
+        key='supabase_url'
+    )
+    
+    supabase_key = st.text_input(
+        "Supabase Key",
+        type="password",
+        placeholder="Ingresa tu Supabase Key",
+        key='supabase_key'
+    )
+
+    # Validación de credenciales
+    if not all([genai_api_key, supabase_url, supabase_key]):
+        st.warning("Por favor ingresa todas las credenciales necesarias.")
+    else:
+        genai.configure(api_key=genai_api_key)
+        model = genai.GenerativeModel('gemini-1.5-flash')
+        st.success("✅ Credenciales configuradas correctamente")
+
+    st.sidebar.markdown(
+        f'''
+        <div style="text-align: center; margin-bottom: 20px;">
+            <a href="https://jersonalvr.shinyapps.io/prophet/" target="_blank" style="text-decoration: none; color: inherit;">Analizar series temporales</a>
+            <br></br>
+            Elaborado por 
+            <a href="https://www.linkedin.com/in/jersonalvr" target="_blank" style="text-decoration: none; color: inherit;">
+                <img src="https://cdn-icons-png.flaticon.com/512/174/174857.png" alt="LinkedIn" width="20" style="vertical-align: middle; margin-right: 5px;"/>
+                Jerson Ruiz Alva
+            </a>
+        </div>
+        ''',
+        unsafe_allow_html=True
+    )
+
+# Configuración de estilos de navegación
+pages = ["Upload", "Prepare", "Training", "ModelTest", "Unsupervised"]
+
+selected_page = option_menu(
+    None,
+    options=pages,
+    icons=['cloud-upload', 'gear', 'robot', 'folder-check', 'search'],
+    default_index=0,
+    orientation="horizontal",
+    styles={
+        "container": {"padding": "0!important", "background-color": None},
+        "icon": {"color": None, "font-size": "20px"}, 
+        "nav-link": {
+            "font-size": "15px",
+            "text-align": "center",
+            "margin": "0px",
+            "--hover-color": "rgba(15, 21, 34, 0.25)",
+        },
+        "nav-link-selected": {"background-color": "rgba(15, 21, 34, 1)"},
+    }
+)
+
+# The rest of the page routing remains the same
+if selected_page == "Upload":
+    show_upload()
+elif selected_page == "Prepare":
+    show_prepare()
+elif selected_page == "Training":
+    show_train()
+elif selected_page == "Test":
+    show_test()
+elif selected_page == "Unsupervised":
+    show_unsupervised()

assets/gemini_logo.json

@@ -0,0 +1 @@
+{"v":"4.8.0","meta":{"g":"LottieFiles AE ","a":"","k":"","d":"","tc":""},"fr":25,"ip":0,"op":51,"w":1000,"h":1000,"nm":"Typing Element_Torus 1","ddd":0,"assets":[{"id":"comp_0","layers":[{"ddd":0,"ind":3,"ty":3,"nm":"Null 56","sr":1,"ks":{"o":{"a":0,"k":0,"ix":11},"r":{"a":1,"k":[{"i":{"x":[0.833],"y":[0.833]},"o":{"x":[0.167],"y":[0.167]},"t":0,"s":[0]},{"i":{"x":[0.833],"y":[0.833]},"o":{"x":[0.167],"y":[0.167]},"t":25,"s":[360]},{"t":50,"s":[720]}],"ix":10},"p":{"a":0,"k":[964,550,0],"ix":2},"a":{"a":0,"k":[0,0,0],"ix":1},"s":{"a":0,"k":[280,280,100],"ix":6}},"ao":0,"ip":0,"op":1750,"st":0,"bm":0},{"ddd":0,"ind":4,"ty":4,"nm":"Layer 3 Outlines","parent":3,"sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[-33.838,-5.16,0],"ix":2},"a":{"a":0,"k":[270.284,191.035,0],"ix":1},"s":{"a":0,"k":[110,110,100],"ix":6}},"ao":0,"ef":[{"ty":29,"nm":"Gaussian Blur","np":5,"mn":"ADBE Gaussian Blur 2","ix":3,"en":1,"ef":[{"ty":0,"nm":"Blurriness","mn":"ADBE Gaussian Blur 2-0001","ix":1,"v":{"a":0,"k":150,"ix":1}},{"ty":7,"nm":"Blur Dimensions","mn":"ADBE Gaussian Blur 2-0002","ix":2,"v":{"a":0,"k":1,"ix":2}},{"ty":7,"nm":"Repeat Edge Pixels","mn":"ADBE Gaussian Blur 2-0003","ix":3,"v":{"a":0,"k":1,"ix":3}}]}],"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[-51.873,0],[0,-51.873],[51.873,0],[0,51.873]],"o":[[51.873,0],[0,51.873],[-51.873,0],[0,-51.873]],"v":[[0,-93.925],[93.925,0],[0,93.925],[-93.925,0]],"c":true},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"fl","c":{"a":0,"k":[0.552941176471,0.490196108351,1,1],"ix":4},"o":{"a":0,"k":100,"ix":5},"r":1,"bm":0,"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill","hd":false},{"ty":"tr","p":{"a":0,"k":[305.506,94.175],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[138,138],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Group 1","np":2,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false},{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[-85.37,0],[0,-85.371],[85.37,0],[0,85.37]],"o":[[85.37,0],[0,85.37],[-85.37,0],[0,-85.371]],"v":[[0,-154.577],[154.577,0],[0,154.577],[-154.577,0]],"c":true},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"fl","c":{"a":0,"k":[0.470588265213,0.831372608858,1,1],"ix":4},"o":{"a":0,"k":100,"ix":5},"r":1,"bm":0,"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill","hd":false},{"ty":"tr","p":{"a":0,"k":[154.827,195.919],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[116,116],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Group 2","np":2,"cix":2,"bm":0,"ix":2,"mn":"ADBE Vector Group","hd":false},{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[-64.842,0],[0,-64.842],[64.842,0],[0,64.842]],"o":[[64.842,0],[0,64.842],[-64.842,0],[0,-64.842]],"v":[[0,-117.406],[117.406,0],[0,117.406],[-117.406,0]],"c":true},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"fl","c":{"a":0,"k":[0.980392216701,0.529411764706,0.901960844152,1],"ix":4},"o":{"a":0,"k":100,"ix":5},"r":1,"bm":0,"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill","hd":false},{"ty":"tr","p":{"a":0,"k":[422.912,264.413],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[142,142],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Group 3","np":2,"cix":2,"bm":0,"ix":3,"mn":"ADBE Vector Group","hd":false}],"ip":0,"op":500,"st":0,"bm":2}]}],"layers":[{"ddd":0,"ind":1,"ty":4,"nm":"Layer 1 Outlines 2","td":1,"sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[93.132,72.852,0],"ix":2},"a":{"a":0,"k":[0,-4,0],"ix":1},"s":{"a":0,"k":[507,507,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[-6.408,1.204],[-0.04,0.008],[-1.08,1.379],[0,1.711],[1.083,1.379],[1.789,0.375],[0.034,0.007],[7.959,2.856],[5.245,4.574],[2.402,15.036],[0.055,0.2],[1.312,1.036],[0,0],[1.73,0],[1.327,-1.049],[0.427,-1.57],[0.033,-0.205],[14.812,-13.222],[0,0],[8.02,-2.876],[6.419,-1.146],[0.057,-0.012],[1.081,-1.379],[0,0],[0,-1.698],[-1.082,-1.381],[-1.787,-0.375],[-0.04,-0.008],[-7.961,-2.855],[-5.223,-4.587],[-2.42,-13.771],[-0.005,-0.03],[-1.344,-1.152],[-1.826,0],[-1.355,1.163],[-0.323,1.682],[0,0],[0,0],[-14.883,13.332],[-8.014,2.877]],"o":[[0.04,-0.007],[1.792,-0.376],[1.077,-1.376],[0,-1.707],[-1.079,-1.377],[-0.035,-0.007],[-6.416,-1.223],[-8.014,-2.876],[-14.817,-13.384],[-0.032,-0.205],[-0.429,-1.578],[0,0],[-1.322,-1.043],[-1.726,0],[-1.319,1.041],[-0.055,0.2],[-2.408,15.071],[0,0],[-5.181,4.633],[-7.948,2.851],[-0.058,0.01],[-1.785,0.375],[0,0],[-1.085,1.384],[0,1.704],[1.081,1.382],[0.04,0.008],[6.409,1.204],[8.021,2.876],[14.927,13.447],[0.005,0.03],[0.323,1.682],[1.356,1.164],[1.829,0],[1.343,-1.152],[0,0],[0,0],[2.383,-13.866],[5.225,-4.59],[7.951,-2.854]],"v":[[73.819,8.807],[73.938,8.784],[78.358,6.026],[80,1.253],[78.353,-3.524],[73.938,-6.276],[73.835,-6.297],[51.296,-12.296],[30.625,-23.432],[7.499,-73.717],[7.368,-74.324],[4.705,-78.363],[4.7,-78.366],[0,-80],[-4.705,-78.362],[-7.368,-74.324],[-7.499,-73.717],[-30.637,-23.421],[-30.641,-23.417],[-51.229,-12.186],[-73.768,-6.309],[-73.94,-6.276],[-78.354,-3.524],[-78.358,-3.519],[-80,1.253],[-78.358,6.026],[-73.94,8.783],[-73.82,8.807],[-51.282,14.776],[-30.63,25.934],[-7.449,73.686],[-7.433,73.776],[-4.887,78.173],[0.035,80],[4.958,78.173],[7.503,73.776],[7.51,73.737],[7.523,73.665],[30.659,25.939],[51.301,14.775]],"c":true},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"fl","c":{"a":0,"k":[1,1,1,1],"ix":4},"o":{"a":0,"k":100,"ix":5},"r":1,"bm":0,"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill","hd":false},{"ty":"tr","p":{"a":0,"k":[80.25,80.25],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Group 1","np":2,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false}],"ip":0,"op":250,"st":0,"bm":0},{"ddd":0,"ind":2,"ty":0,"nm":"Typing_fractal nois","tt":1,"refId":"comp_0","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[500,500,0],"ix":2},"a":{"a":0,"k":[960,540,0],"ix":1},"s":{"a":0,"k":[109,109,100],"ix":6}},"ao":0,"w":1920,"h":1080,"ip":0,"op":250,"st":0,"bm":0},{"ddd":0,"ind":4,"ty":4,"nm":"Layer 1 Outlines 5","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":0,"k":0,"ix":10},"p":{"a":0,"k":[93.132,72.852,0],"ix":2},"a":{"a":0,"k":[0,-4,0],"ix":1},"s":{"a":0,"k":[507,507,100],"ix":6}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ix":1,"ks":{"a":0,"k":{"i":[[-6.408,1.204],[-0.04,0.008],[-1.08,1.379],[0,1.711],[1.083,1.379],[1.789,0.375],[0.034,0.007],[7.959,2.856],[5.245,4.574],[2.402,15.036],[0.055,0.2],[1.312,1.036],[0,0],[1.73,0],[1.327,-1.049],[0.427,-1.57],[0.033,-0.205],[14.812,-13.222],[0,0],[8.02,-2.876],[6.419,-1.146],[0.057,-0.012],[1.081,-1.379],[0,0],[0,-1.698],[-1.082,-1.381],[-1.787,-0.375],[-0.04,-0.008],[-7.961,-2.855],[-5.223,-4.587],[-2.42,-13.771],[-0.005,-0.03],[-1.344,-1.152],[-1.826,0],[-1.355,1.163],[-0.323,1.682],[0,0],[0,0],[-14.883,13.332],[-8.014,2.877]],"o":[[0.04,-0.007],[1.792,-0.376],[1.077,-1.376],[0,-1.707],[-1.079,-1.377],[-0.035,-0.007],[-6.416,-1.223],[-8.014,-2.876],[-14.817,-13.384],[-0.032,-0.205],[-0.429,-1.578],[0,0],[-1.322,-1.043],[-1.726,0],[-1.319,1.041],[-0.055,0.2],[-2.408,15.071],[0,0],[-5.181,4.633],[-7.948,2.851],[-0.058,0.01],[-1.785,0.375],[0,0],[-1.085,1.384],[0,1.704],[1.081,1.382],[0.04,0.008],[6.409,1.204],[8.021,2.876],[14.927,13.447],[0.005,0.03],[0.323,1.682],[1.356,1.164],[1.829,0],[1.343,-1.152],[0,0],[0,0],[2.383,-13.866],[5.225,-4.59],[7.951,-2.854]],"v":[[73.819,8.807],[73.938,8.784],[78.358,6.026],[80,1.253],[78.353,-3.524],[73.938,-6.276],[73.835,-6.297],[51.296,-12.296],[30.625,-23.432],[7.499,-73.717],[7.368,-74.324],[4.705,-78.363],[4.7,-78.366],[0,-80],[-4.705,-78.362],[-7.368,-74.324],[-7.499,-73.717],[-30.637,-23.421],[-30.641,-23.417],[-51.229,-12.186],[-73.768,-6.309],[-73.94,-6.276],[-78.354,-3.524],[-78.358,-3.519],[-80,1.253],[-78.358,6.026],[-73.94,8.783],[-73.82,8.807],[-51.282,14.776],[-30.63,25.934],[-7.449,73.686],[-7.433,73.776],[-4.887,78.173],[0.035,80],[4.958,78.173],[7.503,73.776],[7.51,73.737],[7.523,73.665],[30.659,25.939],[51.301,14.775]],"c":true},"ix":2},"nm":"Path 1","mn":"ADBE Vector Shape - Group","hd":false},{"ty":"fl","c":{"a":0,"k":[1,1,1,1],"ix":4},"o":{"a":0,"k":100,"ix":5},"r":1,"bm":0,"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill","hd":false},{"ty":"tr","p":{"a":0,"k":[80.25,80.25],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Group 1","np":2,"cix":2,"bm":0,"ix":1,"mn":"ADBE Vector Group","hd":false}],"ip":0,"op":250,"st":0,"bm":0}],"markers":[]}

datos/__init__.py

@@ -0,0 +1 @@
+# __init__.py - M�dulo para src data

datos/prepare.py

@@ -0,0 +1,757 @@
+# prepare.py - Módulo para datos
+import streamlit as st 
+import pandas as pd
+import numpy as np
+import plotly.express as px
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from datetime import datetime
+from ydata_profiling import ProfileReport
+import os
+
+def show_prepare():
+    # Crear un contenedor para mensajes de estado
+    status_container = st.empty()
+    
+    # Verificar si hay datos cargados
+    if 'er_data' not in st.session_state:
+        status_container.warning("⚠️ No hay datos cargados. Por favor, carga un dataset en la página Upload primero.")
+        return
+    
+    try:
+        # Usar los datos preparados si existen, si no, usar los datos originales
+        if 'temp_prepared_data' in st.session_state:
+            prepare = st.session_state.temp_prepared_data.copy()
+        else:
+            # Si no hay datos temporales, intentar usar datos preparados permanentes
+            if 'prepared_data' in st.session_state:
+                prepare = st.session_state.prepared_data.copy()
+            else:
+                prepare = st.session_state.er_data.copy()
+            st.session_state.temp_prepared_data = prepare.copy()
+    except AttributeError:
+        status_container.warning("⚠️ No hay datos cargados o los datos son inválidos.")
+        return
+        
+    # Análisis de valores únicos por columna
+    st.markdown("### Análisis de Valores Únicos por Columna")
+
+    # Selección de columnas para analizar - sin selección por defecto
+    all_columns = prepare.columns.tolist()
+    selected_columns = st.multiselect(
+        "Seleccionar columnas para analizar",
+        all_columns,
+        default=[],  # Sin selección por defecto
+        key="unique_values_columns",
+        help="Selecciona las columnas que deseas analizar"
+    )
+
+    if not selected_columns:
+        st.info("👆 Selecciona una o más columnas para ver su análisis detallado.")
+    else:
+        # Controles para número de valores a mostrar
+        col1, col2 = st.columns(2)
+        with col1:
+            n_first = st.number_input(
+                "Número de primeros valores a mostrar",
+                min_value=1,
+                max_value=20,
+                value=5,
+                key="n_first_values"
+            )
+        with col2:
+            n_last = st.number_input(
+                "Número de últimos valores a mostrar",
+                min_value=1,
+                max_value=20,
+                value=5,
+                key="n_last_values"
+            )
+        
+        # Crear tabs para cada columna seleccionada
+        tabs = st.tabs([f"📊 {col}" for col in selected_columns])
+        
+        # Análisis por cada columna seleccionada
+        for tab, col in zip(tabs, selected_columns):
+            with tab:
+                try:
+                    st.markdown(f"### Análisis de {col} ({prepare[col].dtype})")
+                    
+                    # Safely convert column to handle mixed types
+                    column_data = prepare[col].fillna('Sin valor').astype(str)
+                    
+                    valores_unicos = column_data.unique()
+                    n_valores = len(valores_unicos)
+                    
+                    # Información general en columnas
+                    col1, col2, col3 = st.columns([2, 1, 1])
+                    with col1:
+                        st.write(f"Total de valores únicos: {n_valores}")
+                    with col2:
+                        st.write(f"Valores nulos: {prepare[col].isnull().sum()}")
+                    with col3:
+                        st.write(f"% nulos: {(prepare[col].isnull().sum() / len(prepare) * 100).round(2)}%")
+                    
+                    st.markdown("---")
+                    
+                    # Visualización de valores únicos
+                    if n_valores > (n_first + n_last):
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.write("🔼 Primeros valores:")
+                            for valor in valores_unicos[:n_first]:
+                                st.write(f"• {str(valor)}")
+                        
+                        with col2:
+                            st.write("🔽 Últimos valores:")
+                            for valor in valores_unicos[-n_last:]:
+                                st.write(f"• {str(valor)}")
+                    else:
+                        st.write("📝 Todos los valores únicos:")
+                        for valor in valores_unicos:
+                            st.write(f"• '{str(valor)}'")
+                    
+                    st.markdown("---")
+                    
+                    # Distribución de frecuencias
+                    value_counts = column_data.value_counts()
+                    
+                    # Gráfico de barras con conversión segura
+                    fig_bar = {
+                        'data': [{
+                            'type': 'bar',
+                            'x': value_counts.index,
+                            'y': value_counts.values,
+                            'name': 'Frecuencia'
+                        }],
+                        'layout': {
+                            'title': f'Distribución de valores en {col}',
+                            'xaxis': {'title': 'Valor'},
+                            'yaxis': {'title': 'Frecuencia'},
+                            'height': 400,
+                            'showlegend': False
+                        }
+                    }
+                    st.plotly_chart(fig_bar, use_container_width=True)
+                    
+                    # Tabla de frecuencias
+                    freq_df = pd.DataFrame({
+                        'Valor': value_counts.index,
+                        'Frecuencia': value_counts.values,
+                        'Porcentaje': (value_counts.values / len(prepare) * 100).round(2)
+                    })
+                    st.dataframe(freq_df, use_container_width=True)
+                
+                except Exception as e:
+                    st.error(f"Error al procesar la columna {col}")
+                    st.error(str(e))
+                    st.write(f"Detalles técnicos del error en la columna {col}:", e)
+
+    st.subheader("Preparación de Datos")
+
+    st.subheader("Eliminación de Columnas")
+    
+    # Verificar el estado actual de valores nulos
+    current_null_count = prepare.isnull().sum().sum()
+    
+    all_columns = prepare.columns.tolist()
+    columns_to_drop = st.multiselect(
+        "Seleccionar columnas a eliminar",
+        all_columns,
+        key="columns_to_drop"
+    )
+    
+    if columns_to_drop:
+        if st.button("Eliminar columnas seleccionadas", key="drop_columns_button"):
+            try:
+                # Crear una copia temporal antes de eliminar columnas
+                temp_prepare = prepare.copy()
+                
+                # Verificar que las columnas existen antes de eliminarlas
+                missing_cols = [col for col in columns_to_drop if col not in temp_prepare.columns]
+                if missing_cols:
+                    st.error(f"❌ Las siguientes columnas no existen: {', '.join(missing_cols)}")
+                    return
+                
+                # Eliminar las columnas
+                temp_prepare = temp_prepare.drop(columns=columns_to_drop)
+                
+                # Verificar valores nulos después de la eliminación
+                new_null_count = temp_prepare.isnull().sum().sum()
+                
+                if new_null_count <= current_null_count:  # Permitir igual o menor cantidad de nulos
+                    # Actualizar el DataFrame y el estado
+                    prepare = temp_prepare
+                    st.session_state.temp_prepared_data = prepare.copy()
+                    
+                    # Mostrar mensaje de éxito
+                    st.success(f"✅ Columnas eliminadas exitosamente: {', '.join(columns_to_drop)}")
+                    
+                    # Actualizar información sobre valores nulos
+                    if new_null_count == 0:
+                        st.success("✅ No hay valores nulos en los datos.")
+                    else:
+                        st.warning(f"⚠️ Hay {new_null_count} valores nulos en los datos.")
+                        
+                    # Mostrar resumen de las columnas restantes
+                    st.write(f"Columnas restantes: {len(prepare.columns)}")
+                    if st.checkbox("Ver lista de columnas restantes", key="remaining_columns_checkbox"):
+                        st.write(prepare.columns.tolist())
+                else:
+                    st.error(f"❌ La operación incrementaría los valores nulos de {current_null_count} a {new_null_count}. Operación cancelada.")
+                    
+            except Exception as e:
+                st.error(f"Error durante la eliminación de columnas: {str(e)}")
+                st.exception(e)
+
+    # Manejo de valores faltantes
+    st.subheader("Manejo de Valores Faltantes")
+    missing_values = prepare.isnull().sum()
+    missing_percentages = (missing_values / len(prepare) * 100).round(2)
+    
+    # Crear DataFrame y ordenar por número de valores faltantes de mayor a menor
+    missing_df = pd.DataFrame({
+        'Columna': missing_values.index,
+        'Valores Faltantes': missing_values.values,
+        'Porcentaje': missing_percentages.values,
+        'Tipo': prepare[missing_values.index].dtypes
+    })
+    missing_df = missing_df[missing_df['Valores Faltantes'] > 0].sort_values('Valores Faltantes', ascending=False)
+    
+    if not missing_df.empty:
+        # Mostrar advertencia si hay columnas de tipo object con valores faltantes
+        object_cols = missing_df[missing_df['Tipo'] == 'object']
+        if not object_cols.empty:
+            st.warning("⚠️ Se detectaron columnas de tipo texto/categórico (object) con valores faltantes. " 
+                      "Se recomienda revisar estos casos con especial atención ya que el método de imputación "
+                      "podría afectar significativamente el análisis.")
+            
+            st.write("Columnas de tipo texto/categórico con valores faltantes:")
+            st.dataframe(object_cols)
+    
+        st.write("Valores faltantes por columna (ordenados de mayor a menor):")
+        st.dataframe(missing_df)
+
+        # Checkbox para manejo especial de columnas object
+        handle_objects = st.checkbox("Especificar valor de reemplazo para columnas de texto",
+                                   help="Marca esta opción para especificar un valor personalizado para rellenar "
+                                        "los valores faltantes en columnas de texto/categóricas")
+        
+        object_replacement = None
+        if handle_objects:
+            object_replacement = st.text_input("Valor de reemplazo para columnas de texto:",
+                                             value="MISSING",
+                                             help="Este valor se usará para rellenar los valores faltantes "
+                                                  "en todas las columnas de texto/categóricas")
+
+        missing_strategy = st.radio(
+            "Selecciona estrategia para valores faltantes:",
+            ["Eliminar filas", "Rellenar con media", "Rellenar con mediana", "Rellenar con moda"]
+        )
+
+        if st.button("Aplicar estrategia de valores faltantes", key="apply_missing_strategy_button"):
+            try:
+                # Guardar el estado anterior de prepare para verificación
+                nulls_before = prepare.isnull().sum().sum()
+                
+                if missing_strategy == "Eliminar filas":
+                    # Guardar el número de filas antes
+                    rows_before = len(prepare)
+                    
+                    # Crear una copia para no modificar el original
+                    prepare_cleaned = prepare.copy()
+                    
+                    # Eliminar filas con valores nulos
+                    prepare_cleaned = prepare_cleaned.dropna(how='any')
+                    
+                    # Verificar que no queden valores nulos
+                    if prepare_cleaned.isnull().sum().sum() == 0:
+                        prepare = prepare_cleaned  # Actualizar prepare solo si la limpieza fue exitosa
+                        st.session_state.temp_prepared_data = prepare.copy()  # Actualizar el estado temporal
+                        rows_removed = rows_before - len(prepare)
+                        st.success(f"Se eliminaron {rows_removed} filas con valores faltantes. No quedan valores nulos.")
+                    else:
+                        st.error(f"Error: Aún quedan {prepare_cleaned.isnull().sum().sum()} valores faltantes después de la eliminación.")
+                        return
+                else:
+                    # Separar columnas numéricas y no numéricas
+                    numeric_cols = prepare.select_dtypes(include=['int64', 'float64']).columns
+                    non_numeric_cols = prepare.select_dtypes(exclude=['int64', 'float64']).columns
+                    
+                    # Manejar columnas object primero si se especificó un valor de reemplazo
+                    if handle_objects and object_replacement is not None:
+                        object_cols = prepare.select_dtypes(include=['object']).columns
+                        for col in object_cols:
+                            prepare[col] = prepare[col].fillna(object_replacement)
+                    
+                    if missing_strategy == "Rellenar con media":
+                        # Para columnas numéricas usar media
+                        if len(numeric_cols) > 0:
+                            prepare[numeric_cols] = prepare[numeric_cols].fillna(prepare[numeric_cols].mean())
+                        # Para columnas no numéricas sin valor especificado usar moda
+                        if len(non_numeric_cols) > 0 and not handle_objects:
+                            for col in non_numeric_cols:
+                                prepare[col] = prepare[col].fillna(prepare[col].mode()[0] if not prepare[col].mode().empty else 'NA')
+                            
+                    elif missing_strategy == "Rellenar con mediana":
+                        # Para columnas numéricas usar mediana
+                        if len(numeric_cols) > 0:
+                            prepare[numeric_cols] = prepare[numeric_cols].fillna(prepare[numeric_cols].median())
+                        # Para columnas no numéricas sin valor especificado usar moda
+                        if len(non_numeric_cols) > 0 and not handle_objects:
+                            for col in non_numeric_cols:
+                                prepare[col] = prepare[col].fillna(prepare[col].mode()[0] if not prepare[col].mode().empty else 'NA')
+                            
+                    else:  # Rellenar con moda
+                         # Usar moda para todas las columnas que no son object o no tienen valor especificado
+                        for col in prepare.columns:
+                            if prepare[col].dtype in ['object']:
+                                if handle_objects:
+                                    continue  # Ya se manejaron las columnas object
+                            mode_value = prepare[col].mode()
+                            prepare[col] = prepare[col].fillna(mode_value[0] if not mode_value.empty else ('NA' if col in non_numeric_cols else 0))
+
+                    # Actualizar el estado temporal después de la imputación
+                    st.session_state.temp_prepared_data = prepare.copy()
+                
+                # Verificar los cambios
+                nulls_after = prepare.isnull().sum().sum()
+                values_filled = nulls_before - nulls_after
+                
+                if missing_strategy == "Eliminar filas":
+                    st.success(f"Se eliminaron {values_filled} filas con valores faltantes")
+                else:
+                    st.success(f"Se rellenaron {values_filled} valores faltantes")
+                
+                # Verificar si quedan valores nulos
+                remaining_nulls = prepare.isnull().sum()
+                remaining_nulls = remaining_nulls[remaining_nulls > 0]
+                
+                if not remaining_nulls.empty:
+                    st.error("⚠️ Error: Aún quedan valores faltantes en las siguientes columnas:")
+                    for col in remaining_nulls.index:
+                        st.write(f"- {col}: {remaining_nulls[col]} valores faltantes")
+                    st.write("Por favor, contacta al equipo de desarrollo para revisar este error.")
+    
+                # Mostrar un resumen de los datos actualizados
+                st.write("\n### Resumen después del procesamiento:")
+                st.write(f"- Total de filas: {len(prepare)}")
+                st.write(f"- Total de columnas: {len(prepare.columns)}")
+                st.write(f"- Valores faltantes totales: {prepare.isnull().sum().sum()}")
+                    
+                # Verificación final de valores nulos
+                final_null_check = prepare.isnull().sum().sum()
+                if final_null_check == 0:
+                    st.success("✅ ¡No quedan valores faltantes en el dataset!")
+                else:
+                    st.error(f"⚠️ Aún quedan {final_null_check} valores nulos en el dataset.")
+                    return
+
+                # Actualizar la sesión solo si no hay valores nulos
+                if final_null_check == 0:
+                    st.session_state.prepared_data = prepare.copy()
+                    st.session_state.temp_prepared_data = prepare.copy()
+                    # No sobrescribir 'er_data'
+            
+            except Exception as e:
+                st.error(f"Error al procesar valores faltantes: {str(e)}")
+                st.error("Detalles técnicos del error:")
+                st.code(str(e))
+        
+    # Manejo de fechas
+    st.subheader("Manejo de Fechas")
+    with st.expander("Procesamiento de Fechas"):
+        date_columns = st.multiselect(
+            "Seleccionar columnas de fecha",
+            prepare.columns,
+            key="date_columns"
+        )
+        
+        if date_columns:
+            date_format = st.selectbox(
+                "Formato de fecha",
+                [
+                    "yyyy-mm-dd", 
+                    "dd-mm-yyyy", 
+                    "mm-dd-yyyy", 
+                    "yyyy-mm-dd hh:mm",
+                    "dd-mm-yyyy hh:mm",
+                    "mm-dd-yyyy hh:mm",
+                    "yyyy-mm-dd hh:mm:ss",
+                    "dd-mm-yyyy hh:mm:ss",
+                    "mm-dd-yyyy hh:mm:ss",
+                    "hh:mm",
+                    "hh:mm:ss"
+                ],
+                help="Selecciona el formato que coincida con tus datos de fecha/hora."
+            )
+            
+            time_format = st.radio(
+                "Formato de hora",
+                ["24 horas", "12 horas (AM/PM)"],
+                help="Selecciona si el formato de hora está en 12 o 24 horas"
+            )
+            
+            # Ajustar las características disponibles según el formato
+            if date_format in ["hh:mm", "hh:mm:ss"]:
+                available_features = ["Hora del día", "Periodo del día", "Minutos", "Segundos"]
+            else:
+                if "hh:mm:ss" in date_format:
+                    available_features = [
+                        "Año", "Mes", "Día", "Día de la semana", "Trimestre", "Estación", 
+                        "Es fin de semana", "Hora del día", "Periodo del día", "Minutos", "Segundos"
+                    ]
+                else:
+                    available_features = [
+                        "Año", "Mes", "Día", "Día de la semana", "Trimestre", "Estación", 
+                        "Es fin de semana", "Hora del día", "Periodo del día", "Minutos"
+                    ]
+            
+            date_features = st.multiselect(
+                "Seleccionar características a extraer",
+                available_features
+            )
+            
+            if st.button("Procesar fechas", key="process_dates_button"):
+                for col in date_columns:
+                    try:
+                        if date_format in ["hh:mm", "hh:mm:ss"]:
+                            # Procesar solo tiempo
+                            if date_format == "hh:mm:ss":
+                                time_parse_format = '%I:%M:%S %p' if time_format == "12 horas (AM/PM)" else '%H:%M:%S'
+                                time_with_seconds = True
+                            else:
+                                time_parse_format = '%I:%M %p' if time_format == "12 horas (AM/PM)" else '%H:%M'
+                                time_with_seconds = False
+                            
+                            def convert_time(time_str):
+                                try:
+                                    time_obj = datetime.strptime(time_str.strip(), time_parse_format)
+                                    if time_with_seconds:
+                                        return time_obj.hour, time_obj.minute, time_obj.second
+                                    else:
+                                        return time_obj.hour, time_obj.minute, None
+                                except ValueError:
+                                    st.warning(f"⚠️ Formato de hora inesperado en {col}: '{time_str}'")
+                                    return None, None, None if time_with_seconds else None
+                            
+                            # Aplicar la conversión y crear nuevas columnas
+                            hours_minutes_seconds = prepare[col].apply(convert_time)
+                            
+                            # Depuración: Mostrar una vista previa de la conversión
+                            st.write(f"Vista previa de la conversión de tiempo para la columna {col}:")
+                            st.write(hours_minutes_seconds.head())
+                            
+                            if "Hora del día" in date_features:
+                                prepare[f'{col}_hora'] = hours_minutes_seconds.apply(lambda x: x[0] if x and x[0] is not None else None)
+                            if "Minutos" in date_features:
+                                prepare[f'{col}_minutos'] = hours_minutes_seconds.apply(lambda x: x[1] if x and x[1] is not None else None)
+                            if "Segundos" in date_features and time_with_seconds:
+                                prepare[f'{col}_segundos'] = hours_minutes_seconds.apply(lambda x: x[2] if x and x[2] is not None else None)
+                            
+                            # Agregar periodo del día si se seleccionó
+                            if "Periodo del día" in date_features:
+                                def get_period(hour):
+                                    if hour is None:
+                                        return None
+                                    if 5 <= hour < 12:
+                                        return 'Mañana'
+                                    elif 12 <= hour < 17:
+                                        return 'Tarde'
+                                    elif 17 <= hour < 21:
+                                        return 'Noche'
+                                    else:
+                                        return 'Madrugada'
+                                prepare[f'{col}_periodo'] = prepare[f'{col}_hora'].apply(get_period)
+                            
+                        else:
+                            # Definir el formato de parsing según la selección
+                            if date_format == "yyyy-mm-dd":
+                                date_parse_format = '%Y-%m-%d'
+                            elif date_format == "dd-mm-yyyy":
+                                date_parse_format = '%d-%m-%Y'
+                            elif date_format == "mm-dd-yyyy":
+                                date_parse_format = '%m-%d-%Y'
+                            elif date_format == "yyyy-mm-dd hh:mm":
+                                date_parse_format = '%Y-%m-%d %H:%M' if time_format == "24 horas" else '%Y-%m-%d %I:%M %p'
+                            elif date_format == "dd-mm-yyyy hh:mm":
+                                date_parse_format = '%d-%m-%Y %H:%M' if time_format == "24 horas" else '%d-%m-%Y %I:%M %p'
+                            elif date_format == "mm-dd-yyyy hh:mm":
+                                date_parse_format = '%m-%d-%Y %H:%M' if time_format == "24 horas" else '%m-%d-%Y %I:%M %p'
+                            elif date_format == "yyyy-mm-dd hh:mm:ss":
+                                date_parse_format = '%Y-%m-%d %H:%M:%S' if time_format == "24 horas" else '%Y-%m-%d %I:%M:%S %p'
+                            elif date_format == "dd-mm-yyyy hh:mm:ss":
+                                date_parse_format = '%d-%m-%Y %H:%M:%S' if time_format == "24 horas" else '%d-%m-%Y %I:%M:%S %p'
+                            elif date_format == "mm-dd-yyyy hh:mm:ss":
+                                date_parse_format = '%m-%d-%Y %H:%M:%S' if time_format == "24 horas" else '%m-%d-%Y %I:%M:%S %p'
+                            else:
+                                st.error(f"Formato de fecha no reconocido: {date_format}")
+                                continue
+                            
+                            # Convertir a datetime con manejo de errores
+                            temp_dates = pd.to_datetime(prepare[col], format=date_parse_format, errors='coerce')
+                            
+                            # Depuración: Mostrar una vista previa de las fechas parseadas
+                            st.write(f"Vista previa de las fechas parseadas para la columna {col}:")
+                            st.write(temp_dates.head())
+                            
+                            # Manejo de valores que no se pudieron parsear
+                            if temp_dates.isnull().any():
+                                st.warning(f"⚠️ Algunas fechas en la columna {col} no pudieron ser parseadas y se asignaron como NaT.")
+                            
+                            # Extraer características según selección
+                            if "Año" in date_features:
+                                prepare[f'{col}_año'] = temp_dates.dt.year
+                            if "Mes" in date_features:
+                                prepare[f'{col}_mes'] = temp_dates.dt.month
+                            if "Día" in date_features:
+                                prepare[f'{col}_dia'] = temp_dates.dt.day
+                            if "Día de la semana" in date_features:
+                                prepare[f'{col}_dia_semana'] = temp_dates.dt.dayofweek + 1
+                            if "Trimestre" in date_features:
+                                prepare[f'{col}_trimestre'] = temp_dates.dt.quarter
+                            if "Es fin de semana" in date_features:
+                                prepare[f'{col}_fin_semana'] = temp_dates.dt.dayofweek.isin([5, 6]).astype(int)
+                            if "Estación" in date_features:
+                                def get_season(month):
+                                    if month in [12, 1, 2]:
+                                        return 'Invierno'
+                                    elif month in [3, 4, 5]:
+                                        return 'Primavera'
+                                    elif month in [6, 7, 8]:
+                                        return 'Verano'
+                                    else:
+                                        return 'Otoño'
+                                prepare[f'{col}_estacion'] = temp_dates.dt.month.apply(get_season)
+                            if "Hora del día" in date_features and any(sub in date_format for sub in ["hh:mm", "hh:mm:ss"]):
+                                prepare[f'{col}_hora'] = temp_dates.dt.hour
+                            if "Minutos" in date_features and any(sub in date_format for sub in ["hh:mm", "hh:mm:ss"]):
+                                prepare[f'{col}_minutos'] = temp_dates.dt.minute
+                            if "Segundos" in date_features and "hh:mm:ss" in date_format:
+                                prepare[f'{col}_segundos'] = temp_dates.dt.second
+                            if "Periodo del día" in date_features and any(sub in date_format for sub in ["hh:mm", "hh:mm:ss"]):
+                                def get_period(hour):
+                                    if hour is None:
+                                        return None
+                                    if 5 <= hour < 12:
+                                        return 'Mañana'
+                                    elif 12 <= hour < 17:
+                                        return 'Tarde'
+                                    elif 17 <= hour < 21:
+                                        return 'Noche'
+                                    else:
+                                        return 'Madrugada'
+                                prepare[f'{col}_periodo'] = temp_dates.dt.hour.apply(get_period)
+                        
+                        # Eliminar la columna original de fecha
+                        prepare = prepare.drop(columns=[col])
+                        st.success(f"Columna {col} procesada exitosamente")
+                    
+                    except Exception as e:
+                        st.error(f"Error procesando {col}: {str(e)}")
+                        st.exception(e)
+        
+        # Actualizar el estado temporal después de procesar fechas
+        st.session_state.temp_prepared_data = prepare.copy()
+        
+    # Codificación de variables categóricas
+    st.subheader("Codificación de Variables Categóricas")
+    categorical_columns = prepare.select_dtypes(include=['object']).columns
+    
+    if len(categorical_columns) > 0:
+        encoding_method = st.radio(
+            "Método de codificación:",
+            ["Label Encoding", "One-Hot Encoding"]
+        )
+        
+        cols_to_encode = st.multiselect(
+            "Seleccionar columnas para codificar",
+            categorical_columns,
+            key="cols_to_encode"
+        )
+        
+        if st.button("Aplicar codificación", key="apply_encoding_button"):
+            if encoding_method == "Label Encoding":
+                le = LabelEncoder()
+                for col in cols_to_encode:
+                    try:
+                        prepare[col] = le.fit_transform(prepare[col].astype(str))
+                        st.success(f"✅ Label Encoding aplicado a la columna '{col}'")
+                    except Exception as e:
+                        st.error(f"Error al codificar la columna {col} con Label Encoding: {str(e)}")
+                # Actualizar el estado temporal después de la codificación
+                st.session_state.temp_prepared_data = prepare.copy()
+            else:  # One-Hot Encoding
+                try:
+                    prepare = pd.get_dummies(prepare, columns=cols_to_encode)
+                    st.success("✅ One-Hot Encoding aplicado")
+                    # Actualizar el estado temporal después de la codificación
+                    st.session_state.temp_prepared_data = prepare.copy()
+                except Exception as e:
+                    st.error(f"Error al aplicar One-Hot Encoding: {str(e)}")
+    
+    # Normalización de variables numéricas
+    st.subheader("Normalización de Variables Numéricas")
+    numeric_columns = prepare.select_dtypes(include=['int64', 'float64']).columns
+    
+    if len(numeric_columns) > 0:
+        cols_to_normalize = st.multiselect(
+            "Seleccionar columnas para normalizar",
+            numeric_columns,
+            key="cols_to_normalize"
+        )
+        
+        if cols_to_normalize and st.button("Aplicar normalización", key="apply_normalization_button"):
+            try:
+                scaler = StandardScaler()
+                prepare[cols_to_normalize] = scaler.fit_transform(prepare[cols_to_normalize])
+                st.success("✅ Normalización aplicada")
+                # Actualizar el estado temporal después de la normalización
+                st.session_state.temp_prepared_data = prepare.copy()
+            except Exception as e:
+                st.error(f"Error al aplicar normalización: {str(e)}")
+    
+    # Guardar datos preparados y mostrar matriz de correlación
+    st.write("### Vista previa de los datos:")
+    st.dataframe(prepare.head())
+    
+    # Información sobre valores nulos
+    null_count = prepare.isnull().sum().sum()
+    if null_count > 0:
+        st.warning(f"⚠️ Hay {null_count} valores nulos en los datos.")
+    else:
+        st.success("✅ No hay valores nulos en los datos.")
+
+    # Matriz de correlación
+    st.subheader("Matriz de Correlación")
+    numerical_columns = prepare.select_dtypes(include=['int64', 'float64']).columns.tolist()
+    
+    if len(numerical_columns) > 1:
+        corr_variables = st.multiselect(
+            "Selecciona las variables para incluir en la matriz de correlación",
+            options=numerical_columns,
+            default=numerical_columns[:min(5, len(numerical_columns))]  # Seleccionar hasta 5 columnas por defecto
+        )
+        
+        if corr_variables:
+            try:
+                # -------------------------------------------
+                # NUEVO: Detección de Outliers y Visualización
+                # -------------------------------------------
+                for var in corr_variables:
+                    # Cálculo de Q1, Q3 e IQR
+                    Q1 = prepare[var].quantile(0.25)
+                    Q3 = prepare[var].quantile(0.75)
+                    IQR = Q3 - Q1
+                    lower_bound = Q1 - 1.5 * IQR
+                    upper_bound = Q3 + 1.5 * IQR
+                    
+                    # Identificación de outliers
+                    outliers = prepare[(prepare[var] < lower_bound) | (prepare[var] > upper_bound)][var]
+                    num_outliers = outliers.shape[0]
+                    
+                    # Mostrar advertencia si hay outliers
+                    if num_outliers > 0:
+                        st.warning(f"⚠️ La variable **{var}** tiene {num_outliers} datos atípicos (outliers) detectados.")
+                    
+                    # Mostrar boxplot usando Plotly
+                    fig_box = px.box(prepare, y=var, title=f'Boxplot de {var}')
+                    st.plotly_chart(fig_box, use_container_width=True)
+                
+                # Calcular y mostrar la matriz de correlación
+                corr_matrix = prepare[corr_variables].corr(method='pearson')
+                
+                # Mapa de calor de correlación
+                fig_corr = px.imshow(
+                    corr_matrix,
+                    text_auto=True,
+                    aspect="auto",
+                    color_continuous_scale='RdBu_r',
+                    title='Matriz de Correlación de Pearson'
+                )
+                st.plotly_chart(fig_corr, use_container_width=True)
+                
+                # Botón de descarga
+                csv_corr = corr_matrix.to_csv(index=True).encode('utf-8')
+                st.download_button(
+                    label="Descargar Matriz de Correlación como CSV",
+                    data=csv_corr,
+                    file_name='matriz_correlacion.csv',
+                    mime='text/csv',
+                )
+                
+                # Análisis de correlaciones significativas
+                st.write("### Análisis de Correlaciones Significativas")
+                threshold = st.slider(
+                    "Selecciona el umbral mínimo de correlación para considerar significativa",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=0.5,
+                    step=0.05
+                )
+                
+                # Obtener y mostrar correlaciones significativas
+                corr_pairs = corr_matrix.unstack()
+                significant_corr = corr_pairs[
+                    (abs(corr_pairs) >= threshold) & 
+                    (abs(corr_pairs) < 1)
+                ].drop_duplicates().sort_values(ascending=False)
+                
+                if not significant_corr.empty:
+                    st.write(f"Correlaciones significativas (|correlación| ≥ {threshold}):")
+                    for (var1, var2), corr_value in significant_corr.items():
+                        st.write(f"- **{var1}** y **{var2}**: correlación de **{corr_value:.2f}**")
+                else:
+                    st.write("No se encontraron correlaciones significativas con el umbral seleccionado.")
+                
+            except Exception as e:
+                st.error(f"Error al calcular la matriz de correlación: {str(e)}")
+        else:
+            st.warning("Por favor, selecciona al menos una variable para mostrar la matriz de correlación.")
+    else:
+        st.warning("No hay suficientes variables numéricas para calcular correlaciones.")
+
+    # Button para guardar datos preparados
+    if st.button("Guardar datos preparados", key="save_prepared_data_button"):
+        try:
+            null_count = prepare.isnull().sum().sum()
+            if null_count == 0:
+                st.session_state.prepared_data = prepare.copy()
+                st.session_state.temp_prepared_data = prepare.copy()
+                st.session_state.data_saved = True
+                st.success("✅ Datos preparados guardados exitosamente")
+                
+                # Generar reporte
+                progress_container = st.empty()
+                with progress_container:
+                    with st.spinner('Generando reporte del dataset...'):
+                        profile = ProfileReport(prepare, title="Dataset Report", explorative=True)
+                        st.session_state.report_html = profile.to_html()
+                        st.success("¡Reporte generado exitosamente!")
+            else:
+                st.error(f"❌ No se pueden guardar los datos. Aún hay {null_count} valores nulos.")
+                st.warning("Por favor, aplica una estrategia de manejo de valores faltantes antes de guardar.")
+        except Exception as e:
+            st.error(f"Error al guardar los datos preparados: {str(e)}")
+
+    # Botones de descarga fuera del bloque principal
+    if 'data_saved' in st.session_state and st.session_state.data_saved:
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            csv = st.session_state.prepared_data.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="Descargar Dataset Preparado",
+                data=csv,
+                file_name="prepared_dataset.csv",
+                mime="text/csv"
+            )
+        
+        with col2:
+            st.download_button(
+                label="Descargar Reporte del Dataset",
+                data=st.session_state.report_html,
+                file_name="dataset_report.html",
+                mime="text/html"
+            )
+
+    st.info("👆 No te olvides de guardar los datos preparados antes de continuar con el análisis en la página Training o Test.")

datos/upload.py

@@ -0,0 +1,687 @@
+# upload.py - Módulo para datos
+import streamlit as st
+import pandas as pd
+import numpy as np
+import io
+import requests
+from typing import Optional, Dict, List
+import importlib.util
+import os
+import plotly.express as px
+from supabase import create_client
+import re
+from pygwalker.api.streamlit import StreamlitRenderer
+
+# Importaciones específicas del proyecto
+from utils.gemini_explainer import generate_dataset_explanation
+
+# Ejemplos de datasets
+DATASET_OPTIONS = {
+    "Iris": "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv",
+    "Titanic": "https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv",
+    "Boston Housing": "https://raw.githubusercontent.com/scikit-learn/scikit-learn/main/sklearn/datasets/data/boston_house_prices.csv",
+    "Wine Quality": "https://raw.githubusercontent.com/uiuc-cse/data-fa14/master/data/wine.csv",
+    "Diabetes": "https://raw.githubusercontent.com/plotly/datasets/master/diabetes.csv"
+}
+
+def check_package(package_name: str) -> bool:
+    """Verifica si un paquete está instalado"""
+    return importlib.util.find_spec(package_name) is not None
+
+def get_supported_formats() -> Dict[str, List[str]]:
+    """Retorna un diccionario con los formatos soportados basado en las dependencias instaladas"""
+    formats = {
+        'CSV': ['csv'],
+        'Excel': ['xls', 'xlsx', 'xlsm', 'xlsb', 'odf', 'ods', 'odt'],
+        'JSON': ['json']
+    }
+    
+    # Verificar soporte para parquet
+    if check_package('pyarrow') or check_package('fastparquet'):
+        formats['Parquet'] = ['parquet']
+    
+    # Verificar soporte para feather
+    if check_package('pyarrow'):
+        formats['Feather'] = ['feather']
+    
+    # Verificar soporte para HDF5
+    if check_package('tables'):
+        formats['HDF5'] = ['h5', 'hdf5']
+    
+    # Verificar soporte para SQLite
+    if check_package('sqlite3'):
+        formats['SQLite'] = ['db', 'sqlite', 'sqlite3']
+    
+    # Verificar soporte para Pickle
+    formats['Pickle'] = ['pkl', 'pickle']
+    
+    # Verificar soporte para STATA
+    if check_package('pandas.io.stata'):
+        formats['STATA'] = ['dta']
+    
+    # Verificar soporte para SAS
+    if check_package('pandas.io.sas'):
+        formats['SAS'] = ['sas7bdat']
+    
+    return formats
+
+def load_file(file_obj: io.BytesIO, file_format: str) -> Optional[pd.DataFrame]:
+    """Carga un archivo en un DataFrame basado en su formato"""
+    try:
+        if file_format in ['csv']:
+            return pd.read_csv(file_obj)
+        elif file_format in ['xls', 'xlsx', 'xlsm', 'xlsb', 'odf', 'ods', 'odt']:
+            return pd.read_excel(file_obj)
+        elif file_format in ['json']:
+            return pd.read_json(file_obj)
+        elif file_format in ['parquet'] and (check_package('pyarrow') or check_package('fastparquet')):
+            return pd.read_parquet(file_obj)
+        elif file_format in ['feather'] and check_package('pyarrow'):
+            return pd.read_feather(file_obj)
+        elif file_format in ['h5', 'hdf5'] and check_package('tables'):
+            return pd.read_hdf(file_obj)
+        elif file_format in ['pkl', 'pickle']:
+            return pd.read_pickle(file_obj)
+        elif file_format in ['dta'] and check_package('pandas.io.stata'):
+            return pd.read_stata(file_obj)
+        elif file_format in ['sas7bdat'] and check_package('pandas.io.sas'):
+            return pd.read_sas(file_obj)
+        elif file_format in ['db', 'sqlite', 'sqlite3'] and check_package('sqlite3'):
+            import sqlite3
+            conn = sqlite3.connect(file_obj)
+            tables = pd.read_sql_query("SELECT name FROM sqlite_master WHERE type='table';", conn)
+            if len(tables) > 0:
+                table_name = st.selectbox("Selecciona una tabla:", tables['name'].tolist())
+                return pd.read_sql_query(f"SELECT * FROM {table_name};", conn)
+            else:
+                st.error("No se encontraron tablas en la base de datos")
+                return None
+    except Exception as e:
+        st.error(f"Error al cargar el archivo: {str(e)}")
+        return None
+
+def load_gsheet(sharing_link: str) -> pd.DataFrame:
+    """Carga un Google Sheet como DataFrame usando su link de compartir"""
+    sheet_export = sharing_link.replace("/edit?usp=sharing", "/export?format=csv")
+    return pd.read_csv(sheet_export)
+
+def convert_to_raw_github_url(url: str) -> str:
+    """Convierte una URL de GitHub en su versión 'raw'"""
+    # Patrón para URLs de GitHub
+    github_pattern = r'https://github\.com/([^/]+/[^/]+)/blob/([^/]+/.*)'
+    
+    if match := re.match(github_pattern, url):
+        # Construir la URL raw
+        return f'https://raw.githubusercontent.com/{match.group(1)}/{match.group(2)}'
+    return url
+
+def load_url_file(url: str) -> Optional[pd.DataFrame]:
+    """Carga un archivo desde una URL detectando automáticamente el formato"""
+    try:
+        # Convertir a URL raw si es una URL de GitHub
+        raw_url = convert_to_raw_github_url(url)
+        
+        # Configurar headers para simular un navegador
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        
+        response = requests.get(raw_url, headers=headers, verify=True)
+        if response.status_code != 200:
+            raise Exception(f"Error al descargar el archivo (Status code: {response.status_code})")
+        
+        content = io.BytesIO(response.content)
+        
+        # Detectar formato basado en la extensión de la URL
+        extension = url.split('.')[-1].lower()
+        
+        # Validar la extensión antes de procesar
+        supported_formats = ['csv', 'xls', 'xlsx', 'xlsm', 'xlsb', 'odf', 'ods', 'odt', 
+                           'json', 'parquet', 'feather', 'h5', 'hdf5', 'pkl', 'pickle',
+                           'dta', 'sas7bdat', 'db', 'sqlite', 'sqlite3']
+        
+        if extension not in supported_formats:
+            st.error(f"Formato de archivo no soportado: {extension}")
+            return None
+        
+        # Verificar que el contenido descargado no esté vacío
+        if len(response.content) == 0:
+            raise Exception("El archivo descargado está vacío")
+        
+        # Para archivos Excel, usar directamente openpyxl
+        if extension in ['xlsx', 'xlsm', 'xlsb']:
+            return pd.read_excel(content, engine='openpyxl')
+        
+        return load_file(content, extension)
+        
+    except requests.exceptions.SSLError:
+        st.error("Error de seguridad SSL al descargar el archivo. Intente con una URL diferente.")
+        return None
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error en la solicitud HTTP: {str(e)}")
+        return None
+    except Exception as e:
+        st.error(f"Error al cargar la URL: {str(e)}")
+        return None
+    
+def show_supabase_setup_info():
+    """Muestra información de configuración para Supabase"""
+    
+    setup_sql = """
+create or replace function get_tables()
+returns table (table_name text)
+language sql
+as $$
+    select table_name::text
+    from information_schema.tables
+    where table_schema = 'public'
+    and table_type = 'BASE TABLE';
+$$;
+"""
+    
+    with st.expander("ℹ️ Configuración de Supabase", expanded=False):
+        st.markdown("""
+        ### Pasos para configurar Supabase
+
+        1. **Crear función RPC en Supabase:**
+            - Ve al Editor SQL de Supabase
+            - Copia y ejecuta el siguiente código:
+        """)
+        
+        # Mostrar el SQL con botón de copiado
+        st.code(setup_sql, language='sql')
+        
+        st.markdown("""
+        2. **Verificar credenciales:**
+            - URL del proyecto: `Settings -> API -> Project URL`
+            - API Key: `Settings -> API -> Project API keys -> anon/public`
+            
+        3. **Permisos necesarios:**
+            - La función necesita acceso a `information_schema.tables`
+            - El usuario debe tener permisos para ejecutar la función RPC
+            
+        4. **Solución de problemas:**
+            - Asegúrate de que existan tablas en el esquema público
+            - Verifica que la base de datos esté activa
+            - Confirma que las políticas de seguridad permitan el acceso
+        """)
+
+def get_supabase_tables(supabase_url: str, supabase_key: str) -> Optional[List[str]]:
+    """Obtiene la lista de tablas disponibles en Supabase"""
+    try:
+        from supabase import create_client, Client
+        
+        # Crear cliente de Supabase
+        supabase: Client = create_client(supabase_url, supabase_key)
+        
+        try:
+            # Intenta primero usando RPC
+            result = supabase.rpc('get_tables').execute()
+            
+            if hasattr(result, 'data') and result.data:
+                tables = [table['table_name'] for table in result.data]
+                if tables:
+                    return sorted(tables)  # Ordenar las tablas alfabéticamente
+        except Exception as rpc_error:
+            st.warning(f"Método RPC falló: {str(rpc_error)}")
+            
+            try:
+                # Si RPC falla, intenta con una consulta SQL directa
+                result = supabase.from_('information_schema.tables')\
+                    .select('table_name')\
+                    .eq('table_schema', 'public')\
+                    .eq('table_type', 'BASE TABLE')\
+                    .execute()
+                
+                if hasattr(result, 'data') and result.data:
+                    return sorted([table['table_name'] for table in result.data])
+            except Exception as sql_error:
+                st.warning(f"Consulta SQL directa falló: {str(sql_error)}")
+                
+                # Último intento usando postgREST
+                try:
+                    result = supabase.table('tables').select('*').execute()
+                    if hasattr(result, 'data') and result.data:
+                        return sorted([table['name'] for table in result.data])
+                except Exception as postgrest_error:
+                    st.error(f"Todos los métodos de consulta fallaron: {str(postgrest_error)}")
+        
+        st.warning("No se encontraron tablas en el esquema público")
+        # Mostrar ayuda de configuración
+        show_supabase_setup_info()
+        return None
+                
+    except Exception as e:
+        st.error(f"Error al conectar con Supabase: {str(e)}")
+        st.write("Detalles del error:", str(e))
+        # Mostrar ayuda de configuración
+        show_supabase_setup_info()
+        return None
+
+def load_supabase_table(supabase_url: str, supabase_key: str, table_name: str) -> Optional[pd.DataFrame]:
+    """Carga una tabla de Supabase como DataFrame"""
+    try:
+        from supabase import create_client, Client
+        
+        # Crear cliente de Supabase
+        supabase: Client = create_client(supabase_url, supabase_key)
+        
+        # Realizar la consulta a la tabla
+        response = supabase.table(table_name).select("*").execute()
+        
+        if hasattr(response, 'data'):
+            df = pd.DataFrame(response.data)
+            if not df.empty:
+                return df
+            else:
+                st.warning(f"La tabla '{table_name}' está vacía")
+                return None
+        else:
+            st.error("No se pudieron obtener datos de la tabla")
+            return None
+            
+    except Exception as e:
+        st.error(f"Error al cargar la tabla de Supabase: {str(e)}")
+        st.write("Detalles del error:", str(e))
+        return None
+        
+def show_upload():
+    """Función principal para cargar y analizar datos"""
+    st.subheader('Aprenda con sus datos')
+    
+    # Inicializar la variable de estado
+    if 'er_data' not in st.session_state:
+        st.session_state.er_data = None
+    
+    # Obtener formatos soportados
+    SUPPORTED_FORMATS = get_supported_formats()
+    accepted_extensions = [ext for formats in SUPPORTED_FORMATS.values() for ext in formats]
+    
+    # Mostrar formatos disponibles
+    with st.expander("Ver formatos soportados"):
+        for format_type, extensions in SUPPORTED_FORMATS.items():
+            st.write(f"**{format_type}**: {', '.join(extensions)}")
+    
+    # Sección de Ejemplos Predeterminados
+    st.markdown("#### 0. Ejemplos Predeterminados")
+    selected_example = st.selectbox(
+        "Selecciona un dataset de ejemplo", 
+        list(DATASET_OPTIONS.keys()) + ["Ninguno"],
+        index=len(DATASET_OPTIONS)  # Seleccionar "Ninguno" por defecto
+    )
+    
+    if selected_example != "Ninguno":
+        example_url = DATASET_OPTIONS[selected_example]
+        if st.button(f"Cargar Dataset de {selected_example}"):
+            try:
+                with st.spinner(f"Cargando dataset {selected_example}..."):
+                    df = load_url_file(example_url)
+                    if df is not None:
+                        st.session_state.er_data = df
+                        st.success(f"Dataset {selected_example} cargado exitosamente")
+            except Exception as e:
+                st.error(f"Error al cargar el dataset de ejemplo: {str(e)}")
+    
+    # Secciones de carga de datos
+    st.markdown("#### 1. Subir Archivo Local")
+    data_file = st.file_uploader("Arrastra o selecciona tu archivo", type=accepted_extensions)
+
+    if data_file:
+        extension = data_file.name.split('.')[-1].lower()
+        df = load_file(data_file, extension)
+        if df is not None:
+            st.session_state.er_data = df
+            st.success(f"Archivo local cargado: {data_file.name}")
+
+    # Carga desde Google Sheet
+    st.markdown("#### 2. Cargar desde Google Sheet")
+    sharing_link = st.text_input(
+        "Link de Google Sheet:",
+        placeholder="https://docs.google.com/spreadsheets/d/SHEET-ID/edit?usp=sharing"
+    )
+    if sharing_link and st.button("Cargar Sheet"):
+        try:
+            st.session_state.er_data = load_gsheet(sharing_link)
+            st.success("Google Sheet cargado exitosamente")
+        except Exception as e:
+            st.error(f"Error al cargar el Google Sheet: {str(e)}")
+
+    # Carga desde URL
+    st.markdown("#### 3. Cargar desde URL")
+    url = st.text_input(
+        'URL del archivo:',
+        placeholder='Ejemplo: https://ejemplo.com/datos.csv'
+    )
+    if url and st.button('Cargar URL'):
+        df = load_url_file(url)
+        if df is not None:
+            st.session_state.er_data = df
+
+    # Carga desde Supabase
+    st.markdown("#### 4. Carga desde Supabase")
+    
+    # Verificar credenciales
+    has_credentials = (
+        'supabase_url' in st.session_state and 
+        'supabase_key' in st.session_state and 
+        st.session_state.supabase_url.strip() and 
+        st.session_state.supabase_key.strip()
+    )
+
+    # Inicializar variables de estado
+    if 'supabase_tables' not in st.session_state:
+        st.session_state.supabase_tables = None
+    if 'supabase_connected' not in st.session_state:
+        st.session_state.supabase_connected = False
+
+    status_container = st.empty()
+
+    if not has_credentials:
+        status_container.warning("👉 Configura tus credenciales de Supabase en la sección superior izquierda antes de continuar.")
+    else:
+        col1, col2 = st.columns([1, 4])
+        
+        with col1:
+            if st.button(
+                "Conectar" if not st.session_state.supabase_connected else "Reconectar",
+                key="connect_supabase",
+                help="Conectar a Supabase y listar tablas disponibles"
+            ):
+                with st.spinner("Conectando a Supabase..."):
+                    tables = get_supabase_tables(
+                        st.session_state.supabase_url,
+                        st.session_state.supabase_key
+                    )
+                    
+                    if tables:
+                        st.session_state.supabase_tables = tables
+                        st.session_state.supabase_connected = True
+                        status_container.success("✅ Conexión exitosa a Supabase")
+                    else:
+                        st.session_state.supabase_connected = False
+                        status_container.error("❌ No se pudieron obtener las tablas. Verifica tus credenciales.")
+
+        if st.session_state.supabase_connected and st.session_state.supabase_tables:
+            table_container = st.container()
+            
+            with table_container:
+                selected_table = st.selectbox(
+                    "Selecciona una tabla:",
+                    st.session_state.supabase_tables,
+                    key="supabase_table_selector"
+                )
+                
+                if st.button("Cargar Tabla", key="load_supabase_table"):
+                    try:
+                        with st.spinner("Cargando datos..."):
+                            df = load_supabase_table(
+                                st.session_state.supabase_url,
+                                st.session_state.supabase_key,
+                                selected_table
+                            )
+                            if df is not None:
+                                st.session_state.er_data = df
+                                st.success(f"✅ Tabla '{selected_table}' cargada exitosamente")
+                            else:
+                                st.error(f"❌ No se pudo cargar la tabla '{selected_table}'. La tabla puede estar vacía.")
+                    except Exception as e:
+                        st.error(f"❌ Error al cargar la tabla: {str(e)}")
+                        st.write("Detalles del error:", str(e))
+
+    # Análisis de datos
+    if st.session_state.er_data is not None:
+        analyze_dataset(st.session_state.er_data)
+    
+    return st.session_state.er_data
+
+def analyze_dataset(data):
+    """Analizar el dataset cargado"""
+    # Generar explicación automática con Gemini
+    if 'dataset_explanation' not in st.session_state:
+        st.session_state.dataset_explanation = None
+
+    has_api_key = 'gemini_api_key' in st.session_state and st.session_state.gemini_api_key
+
+    if st.button(
+        "Explicar Dataset",
+        key="explain_dataset_button",
+        disabled=not has_api_key,
+        help="Requiere API key de Gemini para funcionar"
+    ):
+        st.session_state.dataset_explanation = generate_dataset_explanation(
+            data, 
+            st.session_state.gemini_api_key
+        )
+
+    # Mostrar explicación si existe
+    if st.session_state.dataset_explanation:
+        st.markdown("### Explicación del Dataset")
+        st.write(st.session_state.dataset_explanation)
+
+        # Botón para limpiar explicación
+        if st.button("Limpiar Explicación", key="clear_explanation"):
+            st.session_state.dataset_explanation = None
+            st.rerun()
+    
+    # Mostrar datos si se han cargado
+    # st.markdown("### Dataset Cargado")
+    # st.dataframe(data.head())
+    renderer = StreamlitRenderer(data)
+    renderer.explorer()
+    st.info(f"📊 Dimensiones: {data.shape[0]} filas × {data.shape[1]} columnas")
+    # Mostrar tipos de datos en columnas múltiples
+    with st.expander("📊 Ver tipos de datos por columna", expanded=False):
+        # Slider para número de columnas
+        num_columns = st.slider(
+            "Número de columnas para mostrar tipos de datos", 
+            min_value=1, 
+            max_value=10, 
+            value=5,
+            help="Desliza para ajustar el número de columnas en la visualización de tipos de datos",
+            key="num_columns_slider"
+        )
+        
+        # Obtener tipos de datos de cada columna
+        data_types = data.dtypes.reset_index()
+        data_types.columns = ["Columna", "Tipo de dato"]
+        
+        st.write("**Tipos de datos por columna:**")
+        
+        # Calcular elementos por columna
+        items_per_column = len(data_types) // num_columns + (1 if len(data_types) % num_columns != 0 else 0)
+        
+        # Crear columnas en Streamlit
+        cols = st.columns(num_columns)
+        
+        # Distribuir tipos de datos entre columnas
+        for col_idx in range(num_columns):
+            start_idx = col_idx * items_per_column
+            end_idx = min(start_idx + items_per_column, len(data_types))
+            
+            if start_idx < len(data_types):
+                with cols[col_idx]:
+                    for idx in range(start_idx, end_idx):
+                        st.write(f"**{data_types.iloc[idx]['Columna']}**: {data_types.iloc[idx]['Tipo de dato']}")
+        
+        # Mostrar resumen de tipos de datos
+        st.markdown("---")
+        st.write("**Resumen de tipos de datos:**")
+        type_summary = data.dtypes.value_counts()
+        summary_cols = st.columns(len(type_summary))
+        for i, (dtype, count) in enumerate(type_summary.items()):
+            with summary_cols[i]:
+                st.metric(f"Tipo: {dtype}", f"{count} columnas")
+
+    # Análisis de Variables por Tipo
+    st.markdown("### Análisis de Variables por Tipo")
+    
+    # Crear columnas para mostrar variables numéricas y categóricas
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("#### Variables Numéricas")
+        lista_var_numericas = data.select_dtypes(include=['int64', 'float64']).columns.tolist()
+        
+        if lista_var_numericas:
+            df_numericas = pd.DataFrame({
+                'Variable': lista_var_numericas,
+                'Tipo': [str(data[col].dtype) for col in lista_var_numericas]
+            })
+            st.dataframe(df_numericas, hide_index=True)
+            
+            if st.checkbox("Ver estadísticas básicas de variables numéricas", key="show_numeric_stats"):
+                st.write(data[lista_var_numericas].describe())
+            
+            selected_num_vars = st.multiselect(
+                "Seleccionar variables numéricas para análisis",
+                lista_var_numericas,
+                default=lista_var_numericas[0] if lista_var_numericas else None,
+                key="numeric_vars_select"
+            )
+            
+            if selected_num_vars:
+                st.write("**Histograma de variables seleccionadas:**")
+                for var in selected_num_vars:
+                    fig_hist = px.histogram(
+                        data, 
+                        x=var, 
+                        title=f'Histograma de {var}'
+                    )
+                    st.plotly_chart(fig_hist)
+        else:
+            st.info("No se encontraron variables numéricas en el dataset")
+    
+    with col2:
+        st.markdown("#### Variables Categóricas")
+        lista_var_object = data.select_dtypes(include=['object']).columns.tolist()
+        
+        if lista_var_object:
+            df_categoricas = pd.DataFrame({
+                'Variable': lista_var_object,
+                'Tipo': [str(data[col].dtype) for col in lista_var_object]
+            })
+            st.dataframe(df_categoricas, hide_index=True)
+            
+            if st.checkbox("Ver valores únicos de variables categóricas", key="show_categorical_stats"):
+                selected_cat_var = st.selectbox(
+                    "Seleccionar variable categórica",
+                    lista_var_object,
+                    key="categorical_var_select"
+                )
+                if selected_cat_var:
+                    unique_values = data[selected_cat_var].value_counts()
+                    st.write("Valores únicos en {selected_cat_var}")
+                             
+                    # Gráfico de barras de valores únicos
+                    fig_bar = px.bar(
+                        x=unique_values.index, 
+                        y=unique_values.values, 
+                        title=f'Distribución de {selected_cat_var}'
+                    )
+                    st.plotly_chart(fig_bar)
+
+                    # Tabla de frecuencia
+                    freq_df = pd.DataFrame({
+                        'Valor': unique_values.index, 
+                        'Frecuencia': unique_values.values, 
+                        'Porcentaje': (unique_values.values / len(data) * 100).round(2)
+                    })
+                    st.dataframe(freq_df)
+        else:
+            st.info("No se encontraron variables categóricas en el dataset")
+
+    # Matriz de Correlación para Variables Numéricas
+    st.markdown("### Matriz de Correlación")
+    numeric_columns = data.select_dtypes(include=['int64', 'float64']).columns.tolist()
+
+    if len(numeric_columns) > 1:
+        # Selección de variables para correlación
+        corr_variables = st.multiselect(
+            "Selecciona las variables para la matriz de correlación", 
+            options=numeric_columns, 
+            default=numeric_columns[:min(5, len(numeric_columns))]
+        )
+
+        if corr_variables:
+            # Calcular matriz de correlación
+            corr_matrix = data[corr_variables].corr(method='pearson')
+
+            # Mapa de calor de correlación
+            fig_corr = px.imshow(
+                corr_matrix, 
+                text_auto=True, 
+                aspect="auto", 
+                color_continuous_scale='RdBu_r', 
+                title='Matriz de Correlación de Pearson'
+            )
+            st.plotly_chart(fig_corr, use_container_width=True)
+
+            # Análisis de correlaciones significativas
+            st.write("### Análisis de Correlaciones Significativas")
+            threshold = st.slider(
+                "Umbral mínimo de correlación", 
+                min_value=0.0, 
+                max_value=1.0, 
+                value=0.5, 
+                step=0.05
+            )
+
+            # Obtener correlaciones significativas
+            corr_pairs = corr_matrix.unstack()
+            significant_corr = corr_pairs[
+                (abs(corr_pairs) >= threshold) & 
+                (abs(corr_pairs) < 1)
+            ].sort_values(ascending=False)
+
+            if not significant_corr.empty:
+                st.write(f"Correlaciones significativas (|correlación| ≥ {threshold}):")
+                for (var1, var2), corr_value in significant_corr.items():
+                    st.write(f"- **{var1}** y **{var2}**: correlación de **{corr_value:.2f}**")
+            else:
+                st.write("No se encontraron correlaciones significativas con el umbral seleccionado.")
+
+    else:
+        st.warning("No hay suficientes variables numéricas para calcular correlaciones.")
+
+    # Detección de Outliers
+    st.markdown("### Detección de Outliers")
+    numeric_columns = data.select_dtypes(include=['int64', 'float64']).columns.tolist()
+
+    if numeric_columns:
+        outlier_vars = st.multiselect(
+            "Selecciona variables para análisis de outliers", 
+            options=numeric_columns
+        )
+
+        if outlier_vars:
+            for var in outlier_vars:
+                # Cálculo de Q1, Q3 e IQR
+                Q1 = data[var].quantile(0.25)
+                Q3 = data[var].quantile(0.75)
+                IQR = Q3 - Q1
+                lower_bound = Q1 - 1.5 * IQR
+                upper_bound = Q3 + 1.5 * IQR
+
+                # Identificación de outliers
+                outliers = data[(data[var] < lower_bound) | (data[var] > upper_bound)][var]
+                num_outliers = outliers.shape[0]
+
+                st.write(f"### Análisis de Outliers para {var}")
+                
+                # Boxplot
+                fig_box = px.box(data, y=var, title=f'Boxplot de {var}')
+                st.plotly_chart(fig_box)
+
+                # Resumen de outliers
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("Total de Datos", len(data))
+                with col2:
+                    st.metric("Número de Outliers", num_outliers)
+                with col3:
+                    st.metric("Porcentaje de Outliers", f"{num_outliers/len(data)*100:.2f}%")
+
+                # Mostrar outliers
+                if st.checkbox(f"Mostrar outliers de {var}"):
+                    st.dataframe(outliers)
+    return data

models/__init__.py

@@ -0,0 +1 @@
+# __init__.py - M�dulo para src models

models/test.py

@@ -0,0 +1,388 @@
+# test.py - Módulo para models
+import streamlit as st
+import pandas as pd
+import numpy as np
+import pickle
+import plotly.express as px
+import plotly.graph_objects as go
+import google.generativeai as genai
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import (
+    mean_squared_error, 
+    r2_score, 
+    mean_absolute_percentage_error,
+    accuracy_score,
+    precision_score,
+    recall_score,
+    f1_score,
+    confusion_matrix,
+    classification_report
+)
+from sklearn.preprocessing import LabelEncoder
+import io
+
+class ModelTester:
+    def __init__(self, model, X, y, problem_type):
+        self.model = model
+        self.X = X
+        self.y = y
+        self.problem_type = problem_type
+        self.label_encoder = None
+
+    def _prepare_data(self, test_size=0.2, random_state=42):
+        """Preparar datos para prueba"""
+        X_train, X_test, y_train, y_test = train_test_split(
+            self.X, self.y, 
+            test_size=test_size, 
+            random_state=random_state,
+            stratify=self.y if self.problem_type == 'classification' else None
+        )
+        return X_train, X_test, y_train, y_test
+
+    def _encode_target(self, y):
+        """Codificar variable objetivo para clasificación"""
+        if self.problem_type == 'classification':
+            self.label_encoder = LabelEncoder()
+            return self.label_encoder.fit_transform(y)
+        return y
+
+    def evaluate_regression(self, X_test, y_test):
+        """Evaluar modelo de regresión"""
+        y_pred = self.model.predict(X_test)
+        
+        metrics = {
+            'MSE': mean_squared_error(y_test, y_pred),
+            'R² Score': r2_score(y_test, y_pred),
+            'MAPE': mean_absolute_percentage_error(y_test, y_pred) * 100
+        }
+        
+        return metrics, y_pred
+
+    def evaluate_classification(self, X_test, y_test):
+        """Evaluar modelo de clasificación"""
+        y_test_encoded = self._encode_target(y_test)
+        y_pred = self.model.predict(X_test)
+        
+        metrics = {
+            'Accuracy': accuracy_score(y_test_encoded, y_pred),
+            'Precision': precision_score(y_test_encoded, y_pred, average='weighted'),
+            'Recall': recall_score(y_test_encoded, y_pred, average='weighted'),
+            'F1 Score': f1_score(y_test_encoded, y_pred, average='weighted')
+        }
+        
+        return metrics, y_pred
+
+    def plot_regression_results(self, y_test, y_pred):
+        """Crear gráfico de resultados de regresión"""
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(
+            x=y_test, y=y_pred, 
+            mode='markers', 
+            name='Predicciones vs Valores Reales'
+        ))
+        fig.add_trace(go.Scatter(
+            x=[y_test.min(), y_test.max()], 
+            y=[y_test.min(), y_test.max()], 
+            mode='lines', 
+            name='Línea Perfecta',
+            line=dict(color='red', dash='dash')
+        ))
+        fig.update_layout(
+            title='Predicciones vs Valores Reales',
+            xaxis_title='Valores Reales',
+            yaxis_title='Predicciones'
+        )
+        return fig
+
+    def plot_classification_results(self, y_test, y_pred):
+        """Crear matriz de confusión para clasificación"""
+        cm = confusion_matrix(
+            self._encode_target(y_test), 
+            y_pred
+        )
+        
+        fig = px.imshow(
+            cm, 
+            labels=dict(x="Predicción", y="Real"),
+            x=[str(c) for c in self.label_encoder.classes_] if self.label_encoder else None,
+            y=[str(c) for c in self.label_encoder.classes_] if self.label_encoder else None,
+            title="Matriz de Confusión"
+        )
+        return fig
+
+def load_model(uploaded_file):
+    """Cargar modelo desde archivo pickle"""
+    try:
+        with uploaded_file as f:
+            model = pickle.load(f)
+        return model
+    except Exception as e:
+        st.error(f"Error al cargar el modelo: {e}")
+        return None
+    
+def get_model_features(model):
+    """Extract feature names from the model if available."""
+    if hasattr(model, 'feature_names_in_'):
+        return list(model.feature_names_in_)
+    return None
+
+def align_features(X, model_features):
+    """Align input features with model's expected features."""
+    if model_features is None:
+        return X
+    
+    # Create a new DataFrame with the correct features in the correct order
+    missing_cols = set(model_features) - set(X.columns)
+    extra_cols = set(X.columns) - set(model_features)
+    
+    if missing_cols:
+        st.warning(f"Missing features: {missing_cols}. These will need to be provided.")
+        return None
+    
+    if extra_cols:
+        st.warning(f"Extra features detected: {extra_cols}. These will be ignored.")
+    
+    return X[model_features]
+
+def determine_problem_type(model):
+    """Determine if the model is for classification or regression."""
+    class_methods = ['predict_proba', 'classes_']
+    return 'classification' if any(hasattr(model, method) for method in class_methods) else 'regression'
+
+def generate_model_explanation(model, metrics, problem_type):
+    """Generar explicación del modelo usando Gemini"""
+    try:
+        genai.configure(api_key=st.session_state.get('gemini_api_key'))
+        model_ai = genai.GenerativeModel('gemini-1.5-flash')
+
+        metrics_text = "\n".join([f"{k}: {v}" for k, v in metrics.items()])
+        
+        prompt = f"""Analiza los siguientes resultados de un modelo de {problem_type}:
+
+        Métricas de Rendimiento:
+        {metrics_text}
+
+        Proporciona:
+        1. Interpretación de las métricas
+        2. Fortalezas y debilidades del modelo
+        3. Posibles mejoras o alternativas
+        4. Contexto práctico de estos resultados
+        """
+
+        response = model_ai.generate_content(prompt)
+        return response.text
+    except Exception as e:
+        st.error(f"Error generando explicación: {e}")
+        return "No se pudo generar la explicación."
+
+def show_test():
+    st.title("Prueba de Modelo")
+
+    # Cargar modelo
+    uploaded_model = st.file_uploader(
+        "Cargar modelo entrenado", 
+        type=['pkl']
+    )
+
+    if not uploaded_model:
+        st.warning("Por favor, cargue un modelo entrenado")
+        return
+
+    # Cargar datos preparados
+    if 'prepared_data' not in st.session_state:
+        st.warning("No hay datos preparados. Por favor, prepare los datos primero.")
+        return
+
+    data = st.session_state.prepared_data
+
+    # Selección de características y objetivo
+    st.subheader("Configuración de Prueba")
+    
+    # Columnas numéricas
+    model_features = get_model_features(uploaded_model)
+    numeric_cols = data.select_dtypes(include=['int64', 'float64']).columns.tolist()
+    
+    if model_features:
+        # Pre-select features that match the model's expected features
+        default_features = [col for col in model_features if col in numeric_cols]
+        feature_cols = st.multiselect(
+            "Seleccionar variables predictoras (X):",
+            numeric_cols,
+            default=default_features
+        )
+    else:
+        feature_cols = st.multiselect(
+            "Seleccionar variables predictoras (X):",
+            numeric_cols,
+            default=st.session_state.get('feature_cols', [])
+        )
+    
+    available_targets = [col for col in data.columns if col not in feature_cols]
+    target_col = st.selectbox(
+        "Seleccionar variable objetivo (y):",
+        available_targets,
+        index=available_targets.index(st.session_state.get('target_col', available_targets[0]))
+        if st.session_state.get('target_col') in available_targets else 0
+    )
+
+    if not feature_cols or not target_col:
+        st.warning("Seleccione variables predictoras y objetivo")
+        return
+
+    # Cargar modelo
+    model = load_model(uploaded_model)
+    if not model:
+        return
+
+    # Preparar datos
+    X = data[feature_cols]
+    y = data[target_col]
+
+    # Determinar tipo de problema
+    problem_type = 'classification' if y.dtype == 'object' or y.nunique() <= 10 else 'regression'
+    st.write(f"Tipo de problema detectado: {problem_type}")
+
+    # Opciones de prueba
+    test_size = st.slider(
+        "Tamaño del conjunto de prueba", 
+        0.1, 0.5, 0.2
+    )
+
+    # Probar modelo
+    if 'model_evaluated' not in st.session_state:
+        st.session_state.model_evaluated = False
+
+    if st.button("Evaluar Modelo"):
+        # Crear tester
+        model_tester = ModelTester(model, X, y, problem_type)
+        
+        # Preparar datos
+        X_train, X_test, y_train, y_test = model_tester._prepare_data(test_size)
+
+        # Evaluar modelo según el tipo de problema
+        if problem_type == 'regression':
+            metrics, y_pred = model_tester.evaluate_regression(X_test, y_test)
+            
+            # Métricas de rendimiento
+            st.subheader("Métricas de Rendimiento")
+            col1, col2, col3 = st.columns(3)
+            col1.metric("MSE", f"{metrics['MSE']:.4f}")
+            col2.metric("R² Score", f"{metrics['R² Score']:.4f}")
+            col3.metric("MAPE", f"{metrics['MAPE']:.2f}%")
+
+            # Visualización de resultados
+            st.subheader("Visualización de Resultados")
+            fig = model_tester.plot_regression_results(y_test, y_pred)
+            st.plotly_chart(fig, use_container_width=True)
+
+        else:  # Clasificación
+            metrics, y_pred = model_tester.evaluate_classification(X_test, y_test)
+            
+            # Métricas de rendimiento
+            st.subheader("Métricas de Rendimiento")
+            col1, col2, col3, col4 = st.columns(4)
+            col1.metric("Accuracy", f"{metrics['Accuracy']:.4f}")
+            col2.metric("Precision", f"{metrics['Precision']:.4f}")
+            col3.metric("Recall", f"{metrics['Recall']:.4f}")
+            col4.metric("F1 Score", f"{metrics['F1 Score']:.4f}")
+
+            # Matriz de confusión
+            st.subheader("Matriz de Confusión")
+            fig = model_tester.plot_classification_results(y_test, y_pred)
+            st.plotly_chart(fig)
+
+            # Reporte de clasificación
+            st.subheader("Reporte de Clasificación")
+            st.text(classification_report(
+                model_tester._encode_target(y_test), 
+                y_pred
+            ))
+        
+        # Guardar métricas en session state
+        st.session_state.metrics = metrics
+        st.session_state.model_evaluated = True
+
+    # Explicación del modelo con Gemini (fuera del if anterior)
+    st.subheader("Análisis de Resultados")
+    if st.session_state.get('gemini_api_key'):
+        if st.button("Generar Explicación Detallada", disabled=not st.session_state.model_evaluated, help="Evalúa el modelo primero"):
+            with st.spinner("Generando explicación..."):
+                explanation = generate_model_explanation(
+                    model, st.session_state.metrics, problem_type
+                )
+                st.markdown(explanation)
+    else:
+        st.warning("Configure la API key de Gemini para obtener explicaciones detalladas")
+
+        # Predicciones de ejemplo
+        st.subheader("Predicciones de Ejemplo")
+        num_samples = st.slider(
+            "Número de muestras a mostrar", 
+            5, 50, 10
+        )
+
+        # Seleccionar muestras aleatorias
+        sample_indices = np.random.choice(
+            len(X_test), 
+            min(num_samples, len(X_test)), 
+            replace=False
+        )
+        sample_X = X_test.iloc[sample_indices]
+        sample_y_true = y_test.iloc[sample_indices]
+        sample_y_pred = model.predict(sample_X)
+
+        # Crear DataFrame de comparación
+        comparison_df = pd.DataFrame({
+            'Características': [
+                ', '.join([f"{col}: {val}" for col, val in row.items()]) 
+                for _, row in sample_X.iterrows()
+            ],
+            'Valor Real': sample_y_true,
+            'Predicción': sample_y_pred,
+            'Error Absoluto' if problem_type == 'regression' 
+            else 'Predicción Correcta': 
+                np.abs(sample_y_true - sample_y_pred) if problem_type == 'regression' 
+                else (sample_y_true == sample_y_pred)
+        })
+        
+        st.dataframe(comparison_df)
+
+        # Opciones de descarga
+        st.subheader("Descargar Resultados")
+        
+        # Guardar métricas
+        metrics_df = pd.DataFrame.from_dict(metrics, orient='index', columns=['Valor'])
+        
+        # Selector de formato
+        download_format = st.selectbox(
+            "Seleccionar formato de descarga", 
+            ["CSV", "Excel"]
+        )
+
+        if download_format == "CSV":
+            csv_data = metrics_df.to_csv().encode('utf-8')
+            st.download_button(
+                label="Descargar Métricas (CSV)", 
+                data=csv_data, 
+                file_name="model_metrics.csv", 
+                mime="text/csv"
+            )
+        else:
+            excel_buffer = io.BytesIO()
+            with pd.ExcelWriter(excel_buffer, engine='xlsxwriter') as writer:
+                metrics_df.to_excel(writer, index=True, sheet_name='Métricas')
+                comparison_df.to_excel(writer, index=False, sheet_name='Predicciones')
+            excel_buffer.seek(0)
+            st.download_button(
+                label="Descargar Resultados (Excel)", 
+                data=excel_buffer, 
+                file_name="model_results.xlsx", 
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            )
+
+def main():
+    """Función principal para ejecutar la página de prueba de modelos"""
+    show_test()
+
+if __name__ == "__main__":
+    main()

models/train.py

@@ -0,0 +1,829 @@
+# models/train.py
+import time
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split, GridSearchCV
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.pipeline import Pipeline
+from imblearn.over_sampling import SMOTE
+from sklearn.utils import resample
+from sklearn.metrics import (
+    mean_squared_error, r2_score, 
+    accuracy_score, classification_report, confusion_matrix
+)
+import os
+import sys
+import pickle
+import io
+import h2o
+from flaml import AutoML
+from typing import Dict, Any, Optional
+
+# Importaciones
+from utils.model_utils import (
+    ModelTrainer,  # Importar la clase
+    get_model_options,
+    train_model_pipeline,
+    process_classification_data,
+    create_class_distribution_plot
+)
+from utils.gemini_explainer import initialize_gemini_explainer
+from utils.gemini_explainer import generate_model_explanation
+from utils.shap_explainer import create_shap_analysis_dashboard
+
+def safe_init_h2o(url=None, **kwargs):
+    """
+    Safely initialize H2O cluster if not already running.
+    
+    Args:
+        url (str, optional): H2O cluster URL. Defaults to None (local instance).
+        **kwargs: Additional arguments to pass to h2o.init()
+    
+    Returns:
+        h2o._backend.H2OConnection: The H2O connection object
+    """
+    # Get current H2O instance if exists
+    current = h2o.connection()
+    
+    # Check if H2O is already running
+    if current and current.cluster:
+        print("H2O is already running at", current.base_url)
+        return current
+    
+    # Initialize new H2O instance
+    print("Starting new H2O instance...")
+    return h2o.init(url=url, **kwargs)
+
+def convert_h2o_to_pandas(h2o_df):
+    """
+    Convierte un H2OFrame a pandas DataFrame utilizando múltiples hilos.
+    
+    Args:
+        h2o_df (h2o.H2OFrame): Frame de H2O a convertir.
+    
+    Returns:
+        pd.DataFrame: DataFrame de pandas.
+    """
+    return h2o_df.as_data_frame(use_multi_thread=True)
+
+# Obtener la ruta del directorio raíz del proyecto
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+sys.path.insert(0, project_root)
+
+def validate_data_preparation(train):
+    """
+    Validar que los datos estén preparados correctamente
+    
+    Args:
+        train (pd.DataFrame): Datos de entrenamiento
+    
+    Returns:
+        bool: Indica si los datos están listos para entrenamiento
+    """
+    if train is None or train.empty:
+        st.warning("⚠️ No hay datos preparados en la sesión.")
+        return False
+    return True
+
+def select_features_and_target(train):
+    """
+    Permitir al usuario seleccionar características y variable objetivo
+    
+    Args:
+        train (pd.DataFrame): Datos de entrenamiento
+    
+    Returns:
+        tuple: Variables predictoras (X) y variable objetivo (y)
+    """
+    numeric_cols = train.select_dtypes(include=['int64', 'float64']).columns.tolist()
+    
+    # Mantener las selecciones en session_state
+    if 'feature_cols' not in st.session_state:
+        st.session_state.feature_cols = []
+        
+    feature_cols = st.multiselect(
+        "Selecciona las variables predictoras (X):",
+        numeric_cols,
+        default=st.session_state.feature_cols
+    )
+    st.session_state.feature_cols = feature_cols
+    
+    # Obtener TODAS las columnas disponibles para target
+    all_cols = train.columns.tolist()
+    available_targets = [col for col in all_cols if col not in feature_cols]
+    
+    if not available_targets:
+        st.warning("Por favor, deselecciona algunas variables predictoras para poder seleccionar la variable objetivo.")
+        return None, None
+        
+    if ('target_col' not in st.session_state or 
+        st.session_state.target_col not in available_targets):
+        st.session_state.target_col = available_targets[0]
+    
+    target_col = st.selectbox(
+        "Selecciona la variable objetivo (y):",
+        available_targets,
+        index=available_targets.index(st.session_state.target_col)
+    )
+    st.session_state.target_col = target_col
+    
+    if not (feature_cols and target_col):
+        st.warning("Por favor selecciona variables predictoras y objetivo.")
+        return None, None
+        
+    X = train[feature_cols]
+    y = train[target_col]
+    
+    return X, y
+
+def determine_problem_type(y):
+    """
+    Determinar el tipo de problema de machine learning
+    
+    Args:
+        y (pd.Series): Variable objetivo
+    
+    Returns:
+        str: Tipo de problema ('classification' o 'regression')
+    """
+    is_categorical = y.dtype == 'object' or (y.dtype.name.startswith(('int', 'float')) and y.nunique() <= 10)
+    problem_type = 'classification' if is_categorical else 'regression'
+    st.write(f"Tipo de problema identificado: **{problem_type}**")
+    return problem_type
+
+def handle_data_balancing(X, y, random_state):
+    """
+    Manejar el desbalanceo de clases
+    
+    Args:
+        X (pd.DataFrame): Variables predictoras
+        y (pd.Series): Variable objetivo
+        random_state (int): Semilla aleatoria
+    
+    Returns:
+        tuple: Variables predictoras y objetivo balanceadas
+    """
+    if y.value_counts().min() / y.value_counts().max() < 0.5:
+        st.write("⚠️ Se detectó desbalanceo en las clases")
+        balance_method = st.selectbox(
+            "Técnica de balanceo:",
+            ["Ninguno", "Submuestreo", "Sobremuestreo", "SMOTE"]
+        )
+        
+        if balance_method != "Ninguno":
+            with st.spinner("Aplicando técnica de balanceo..."):
+                if balance_method == "Submuestreo":
+                    min_class_size = y.value_counts().min()
+                    X, y = resample(X, y, n_samples=min_class_size*2, stratify=y)
+                elif balance_method == "Sobremuestreo":
+                    max_class_size = y.value_counts().max()
+                    X, y = resample(X, y, n_samples=max_class_size*2, stratify=y)
+                else:  # SMOTE
+                    smote = SMOTE(random_state=random_state)
+                    X, y = smote.fit_resample(X, y)
+            st.success("Balanceo completado!")
+    
+    return X, y
+
+def safe_init_h2o(url=None, **kwargs):
+    """
+    Safely initialize H2O cluster if not already running.
+    
+    Args:
+        url (str, optional): H2O cluster URL. Defaults to None (local instance).
+        **kwargs: Additional arguments to pass to h2o.init()
+    
+    Returns:
+        h2o._backend.H2OConnection: The H2O connection object
+    """
+    # Get current H2O instance if exists
+    current = h2o.connection()
+    
+    # Check if H2O is already running
+    if current and current.cluster:
+        print("H2O is already running at", current.base_url)
+        return current
+    
+    # Initialize new H2O instance
+    print("Starting new H2O instance...")
+    return h2o.init(url=url, **kwargs)
+
+class AutoMLTrainer:
+    """Clase para gestionar el entrenamiento automático de modelos"""
+    
+    @staticmethod
+    def train_h2o_automl(
+        X_train: pd.DataFrame,
+        y_train: pd.Series,
+        X_test: pd.DataFrame,
+        y_test: pd.Series,
+        problem_type: str,
+        time_limit: int = 3600,
+        max_models: int = 20
+    ) -> Dict[str, Any]:
+        """
+        Entrenar modelos usando H2O AutoML con manejo correcto de tipos de datos
+        """
+        try:
+            safe_init_h2o()
+            
+            # Crear un DataFrame combinado con la variable objetivo
+            train_df = X_train.copy()
+            test_df = X_test.copy()
+            
+            # Manejar la variable objetivo según el tipo de problema
+            if problem_type == 'classification':
+                train_df['target'] = y_train.astype(str)
+                test_df['target'] = y_test.astype(str)
+            else:
+                train_df['target'] = y_train.astype(float)
+                test_df['target'] = y_test.astype(float)
+            
+            # Convertir a H2OFrame
+            train = h2o.H2OFrame(train_df)
+            test = h2o.H2OFrame(test_df)
+            
+            # Si es clasificación, convertir explícitamente la columna objetivo a factor
+            if problem_type == 'classification':
+                train['target'] = train['target'].asfactor()
+                test['target'] = test['target'].asfactor()
+            
+            # Especificar columnas
+            feature_cols = X_train.columns.tolist()
+            target_col = 'target'
+            
+            # Configurar AutoML
+            aml = h2o.automl.H2OAutoML(
+                max_runtime_secs=time_limit,
+                max_models=max_models,
+                seed=42,
+                sort_metric="AUTO"
+            )
+            
+            # Entrenar
+            start_time = time.time()
+            aml.train(x=feature_cols, y=target_col, training_frame=train)
+            training_time = time.time() - start_time
+            
+            # Obtener el mejor modelo
+            best_model = aml.leader
+            
+            # Obtener hiperparámetros correctamente
+            hyperparameters = best_model.params
+            
+            # Obtener predicciones
+            preds = best_model.predict(test[feature_cols])
+            predictions = preds.as_data_frame(use_pandas=True)
+            
+            if problem_type == 'classification':
+                predictions = predictions['predict']
+            
+            # Preparar resultados
+            results = {
+                'best_model': best_model,
+                'training_time': training_time,
+                'leaderboard': aml.leaderboard.as_data_frame(),
+                'hyperparameters': hyperparameters,
+                'predictions': predictions
+            }
+            
+            # Métricas según tipo de problema
+            if problem_type == 'classification':
+                results.update({
+                    'test_accuracy': accuracy_score(y_test.astype(str), predictions.astype(str)),
+                    'classification_report': classification_report(
+                        y_test.astype(str), 
+                        predictions.astype(str), 
+                        output_dict=True
+                    )
+                })
+            else:
+                results.update({
+                    'test_rmse': np.sqrt(mean_squared_error(y_test, predictions)),
+                    'test_r2': r2_score(y_test, predictions)
+                })
+            
+            return results
+            
+        except Exception as e:
+            print(f"Error detallado en H2O AutoML: {str(e)}")
+            return {'error': str(e)}
+
+    @staticmethod
+    def train_flaml_automl(
+        X_train: pd.DataFrame,
+        y_train: pd.Series,
+        X_test: pd.DataFrame,
+        y_test: pd.Series,
+        problem_type: str,
+        time_limit: int = 3600,
+        metric: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Entrenar modelos usando FLAML AutoML
+        
+        Args:
+            X_train: Features de entrenamiento
+            y_train: Target de entrenamiento
+            X_test: Features de prueba
+            y_test: Target de prueba
+            problem_type: Tipo de problema
+            time_limit: Límite de tiempo en segundos
+            metric: Métrica de evaluación
+            
+        Returns:
+            Dict con resultados del entrenamiento
+        """
+        try:
+            # Configurar AutoML
+            task = 'classification' if problem_type == 'classification' else 'regression'
+            metric = metric or ('accuracy' if task == 'classification' else 'r2')
+            
+            automl = AutoML()
+            
+            # Entrenar
+            start_time = time.time()
+            automl.fit(
+                X_train=X_train,
+                y_train=y_train,
+                task=task,
+                time_budget=time_limit,
+                metric=metric,
+                verbose=1
+            )
+            training_time = time.time() - start_time
+            
+            # Predicciones
+            predictions = automl.predict(X_test)
+            
+            # Preparar resultados
+            results = {
+                'best_model': automl.model,
+                'best_config': automl.best_config,
+                'training_time': training_time,
+                'best_estimator': automl.best_estimator,
+                'predictions': predictions
+            }
+            
+            # Métricas específicas
+            if problem_type == 'classification':
+                results.update({
+                    'test_accuracy': accuracy_score(y_test, predictions),
+                    'classification_report': classification_report(y_test, predictions, output_dict=True)
+                })
+            else:
+                results.update({
+                    'test_rmse': np.sqrt(mean_squared_error(y_test, predictions)),
+                    'test_r2': r2_score(y_test, predictions)
+                })
+            
+            return results
+            
+        except Exception as e:
+            return {'error': str(e)}
+
+def descargar_modelo_h2o(modelo_h2o, nombre_modelo):
+    """
+    Guarda y prepara el modelo H2O para su descarga.
+    
+    Args:
+        modelo_h2o: Objeto del modelo H2O.
+        nombre_modelo (str): Nombre del modelo para el archivo.
+    
+    Returns:
+        bytes: Contenido del archivo del modelo.
+    """
+    try:
+        # Guardar el modelo en una ruta temporal
+        modelo_path = h2o.save_model(model=modelo_h2o, path="/tmp", force=True)
+        
+        # Leer el archivo del modelo
+        with open(modelo_path, "rb") as file:
+            modelo_data = file.read()
+        
+        # Opcional: Eliminar el archivo temporal después de leerlo
+        os.remove(modelo_path)
+        
+        return modelo_data
+    except Exception as e:
+        st.error(f"Error al preparar el modelo para descarga: {str(e)}")
+        return None
+
+def show_automl_section(X: pd.DataFrame, y: pd.Series, problem_type: str):
+    """Mostrar sección de AutoML"""
+    
+    st.header("🤖 Búsqueda Automática del Mejor Modelo")
+    
+    # Parámetros de AutoML
+    col1, col2 = st.columns(2)
+    with col1:
+        time_limit = st.number_input(
+            "Límite de tiempo (segundos)",
+            min_value=60,
+            max_value=7200,
+            value=3600,
+            step=300,
+            key="automl_time_limit"
+        )
+    
+    with col2:
+        framework = st.selectbox(
+            "Framework AutoML",
+            ["H2O AutoML", "FLAML"],
+            key="automl_framework"
+        )
+    
+    # Inicializar estado para modelos AutoML
+    if 'automl_models' not in st.session_state:
+        st.session_state.automl_models = {}
+    
+    # Botón de entrenamiento
+    train_button = st.button(
+        "Entrenar Modelos Automáticamente",
+        key="train_automl_button",
+        use_container_width=True
+    )
+    
+    if train_button:
+        try:
+            # División de datos
+            X_train, X_test, y_train, y_test = train_test_split(
+                X, y, test_size=0.2, random_state=42,
+                stratify=y if problem_type == 'classification' else None
+            )
+            
+            with st.spinner("Entrenando modelos automáticamente..."):
+                if framework == "H2O AutoML":
+                    results = AutoMLTrainer.train_h2o_automl(
+                        X_train, y_train, X_test, y_test,
+                        problem_type, time_limit
+                    )
+                else:  # FLAML
+                    results = AutoMLTrainer.train_flaml_automl(
+                        X_train, y_train, X_test, y_test,
+                        problem_type, time_limit
+                    )
+                
+                # Almacenar resultados
+                st.session_state.automl_models[framework] = results
+        
+        except Exception as e:
+            st.error(f"Error en entrenamiento AutoML: {str(e)}")
+    
+    # Mostrar resultados si existen
+    if st.session_state.automl_models:
+        for framework, results in st.session_state.automl_models.items():
+            st.subheader(f"Resultados de {framework}")
+            
+            if 'error' in results:
+                st.error(f"Error: {results['error']}")
+                continue
+            
+            # Métricas principales
+            cols = st.columns(3)
+            with cols[0]:
+                st.metric(
+                    "Tiempo de Entrenamiento",
+                    f"{results['training_time']:.2f}s"
+                )
+            
+            with cols[1]:
+                if problem_type == 'classification':
+                    st.metric("Accuracy", f"{results['test_accuracy']:.4f}")
+                else:
+                    st.metric("R² Score", f"{results['test_r2']:.4f}")
+            
+            with cols[2]:
+                if problem_type == 'classification':
+                    st.metric(
+                        "F1 Score",
+                        f"{results['classification_report']['macro avg']['f1-score']:.4f}"
+                    )
+                else:
+                    st.metric("RMSE", f"{results['test_rmse']:.4f}")
+            
+            # Explicación del modelo
+            if st.button("Generar Explicación", key=f"{framework}_explain"):
+                if 'gemini_api_key' in st.session_state:
+                    with st.spinner("Generando explicación..."):
+                        explainer = initialize_gemini_explainer()
+                        model_info = {
+                            'name': framework,
+                            'problem_type': problem_type,
+                            'hyperparameters': results.get('hyperparameters', 'N/A'),
+                            'performance_metric': results.get('test_accuracy', results.get('test_r2', 'N/A')),
+                            'training_time': results.get('training_time', 'N/A')
+                        }
+                        explanation = explainer.generate_model_explanation(model_info)
+                        st.markdown(explanation)
+                else:
+                    st.warning("Configura tu API key de Gemini para generar explicaciones")
+            
+            # Análisis SHAP
+            if st.button("Mostrar Análisis SHAP", key=f"{framework}_shap"):
+                create_shap_analysis_dashboard(
+                    results['best_model'],
+                    X,
+                    problem_type
+                )
+            
+            # Descarga del modelo
+            if st.button("Descargar Modelo", key=f"{framework}_download"):
+                modelo_data = descargar_modelo_h2o(results['best_model'], framework)
+                if modelo_data:
+                    st.download_button(
+                        label=f"Descargar {framework}",
+                        data=modelo_data,
+                        file_name=f"{framework.lower().replace(' ', '_')}_{int(time.time())}.zip",
+                        mime="application/zip",
+                        key=f"{framework}_download_button"
+                    )
+                
+def show_train():
+    """
+    Función principal para mostrar la interfaz de entrenamiento de modelos
+    """
+    st.title("Desarrollo de Modelos")
+    
+    # Verificar preparación de datos
+    if 'prepared_data' not in st.session_state:
+        st.warning("⚠️ No hay datos preparados en la sesión. Por favor, carga y prepara los datos primero.")
+        return
+        
+    if st.session_state.prepared_data is None:
+        st.warning("⚠️ Los datos preparados están vacíos. Por favor, verifica la preparación de datos.")
+        return
+    
+    # Inicializar 'trained_models' si no existe
+    if 'trained_models' not in st.session_state:
+        st.session_state.trained_models = {}
+    
+    train = st.session_state.prepared_data
+    
+    try:
+        # Seleccionar características y objetivo
+        X, y = select_features_and_target(train)
+        if X is None or y is None:
+            return
+        
+        # Verificar valores nulos
+        if X.isnull().sum().sum() > 0 or y.isnull().sum() > 0:
+            st.error("Hay valores nulos en los datos. Por favor, vuelve a la página de preparación y maneja los valores faltantes.")
+            return
+        
+        # Determinar tipo de problema
+        problem_type = determine_problem_type(y)
+        
+        # Configuraciones de entrenamiento
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            test_size = st.slider("Tamaño del conjunto de prueba:", 0.1, 0.5, 0.2)
+        with col2:
+            random_state = st.number_input("Random State:", min_value=0, value=42)
+        with col3:
+            n_folds = st.number_input("Número de folds para validación cruzada:", min_value=2, max_value=10, value=5)
+            st.session_state.n_folds = n_folds
+        
+        # Preprocesamiento de datos para clasificación
+        if problem_type == 'classification':
+            y_original = y
+            le = LabelEncoder()
+            y = pd.Series(le.fit_transform(y))
+            st.session_state.label_encoder = le
+            st.write("Mapeo de clases:", dict(enumerate(le.classes_)))
+            
+            # Visualizar distribución de clases
+            fig = create_class_distribution_plot(y_original)
+            st.plotly_chart(fig)
+            
+            # Manejar desbalanceo de clases
+            X, y = handle_data_balancing(X, y, random_state)
+        
+        show_automl_section(X, y, problem_type)
+        
+        # Obtener opciones de modelos
+        model_options = get_model_options(problem_type)
+        # Gestionar modelos seleccionados
+        if 'selected_models' not in st.session_state:
+            st.session_state.selected_models = []
+    
+        selected_models = st.multiselect(
+            "Selecciona los modelos a entrenar:",
+            list(model_options.keys()),
+            default=st.session_state.selected_models
+        )
+        st.session_state.selected_models = selected_models
+    
+        if not selected_models:
+            st.warning("Por favor selecciona al menos un modelo para entrenar.")
+            return
+    
+        # Configurar re-entrenamiento
+        if st.button("Reentrenar Modelos"):
+            st.session_state.retrain_models = True
+        else:
+            # Solo establecer a False si no está ya en sesión
+            if 'retrain_models' not in st.session_state:
+                st.session_state.retrain_models = False
+    
+        # Dividir datos
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=test_size, random_state=random_state,
+            stratify=y if problem_type == 'classification' else None
+        )
+    
+        # Crear columnas para mostrar resultados de modelos
+        cols = st.columns(len(selected_models))
+        
+        # Entrenar y mostrar resultados de cada modelo
+        for i, model_name in enumerate(selected_models):
+            with cols[i]:
+                st.write(f"### {model_name}")
+                
+                # Verificar si el modelo ya está entrenado y si no se solicita reentrenamiento
+                if (model_name not in st.session_state.trained_models) or st.session_state.retrain_models:
+                    # Entrenar modelo
+                    trained_model = train_model_pipeline(
+                        X_train=X_train,
+                        y_train=y_train,
+                        model_config=model_options[model_name],
+                        X_test=X_test,
+                        y_test=y_test,
+                        cv=st.session_state.n_folds,
+                        scoring=None,
+                        random_state=random_state,  # Pasar random_state
+                        n_jobs=-1,     # Para usar todos los núcleos disponibles
+                        verbose=1
+                    )
+                    
+                    # Almacenar el modelo entrenado en session_state
+                    if 'trained_models' not in st.session_state:
+                        st.session_state.trained_models = {}
+                    st.session_state.trained_models[model_name] = trained_model
+                else:
+                    # Reutilizar el modelo ya entrenado
+                    trained_model = st.session_state.trained_models[model_name]
+                
+                # Mostrar resultados del modelo
+                show_model_results(
+                    model_name, 
+                    problem_type, 
+                    y_test, 
+                    cols[i],
+                    trained_model
+                )
+    
+    except Exception as e:
+        st.error(f"Error inesperado: {str(e)}")
+
+
+def show_model_results(model_name, problem_type, y_test, col, trained_model):
+    """
+    Mostrar resultados detallados de un modelo entrenado
+    
+    Args:
+        model_name (str): Nombre del modelo
+        problem_type (str): Tipo de problema
+        y_test (pd.Series): Datos de prueba
+        col (streamlit.delta_generator.DeltaGenerator): Columna de Streamlit
+        trained_model (dict): Resultados del entrenamiento
+    """
+    with col:
+        # Verificar si el modelo está en la sesión de modelos entrenados
+        if model_name in st.session_state.trained_models:
+            results = st.session_state.trained_models[model_name]
+            
+            # Verificar si hubo un error durante el entrenamiento
+            if 'error' in results:
+                st.error(results['error'])
+                return
+            
+            # Mostrar métricas de rendimiento
+            if 'training_time' in results:
+                st.success(f"¡Entrenamiento completado en {results['training_time']:.2f} segundos!")
+            st.write("Mejores parámetros:", results.get('best_params', 'N/A'))
+            
+            # Métricas específicas según el tipo de problema
+            if problem_type == 'classification':
+                st.write("Accuracy:", results.get('test_accuracy', 'N/A'))
+                st.text("Reporte de clasificación:")
+                st.text(pd.DataFrame(results.get('classification_report', {})).transpose().to_string())
+            else:
+                st.write("R² Score:", results.get('test_r2', 'N/A'))
+                st.write("RMSE:", results.get('test_rmse', 'N/A'))
+            
+            # Sección de explicación de parámetros con Gemini
+            st.write("---")
+            st.write("### Explicación de Parámetros")
+            
+            # Verificar disponibilidad de API key de Gemini
+            has_api_key = 'gemini_api_key' in st.session_state and st.session_state.gemini_api_key
+            
+            if not has_api_key:
+                st.warning("Configure su API key de Gemini en la sección superior izquierda para usar la explicación automática de los parámetros.")
+            
+            # Inicializar el explainer si no lo has hecho ya
+            if 'explainer' not in st.session_state:
+                st.session_state.explainer = initialize_gemini_explainer()
+            
+            explainer = st.session_state.explainer
+            
+            # Inicializar explicaciones en el estado de la sesión
+            if 'model_explanations' not in st.session_state:
+                st.session_state.model_explanations = {}
+            
+            # Botón para generar explicación
+            explain_button = st.button(
+                "Explicar Parámetros",
+                disabled=not has_api_key,
+                key=f"explain_{model_name}"
+            )
+            
+            # Mostrar explicación existente si está disponible
+            if model_name in st.session_state.model_explanations:
+                st.markdown(st.session_state.model_explanations[model_name])
+            
+        # Inicializar el explainer solo cuando se necesite
+        if 'explain_button' in locals() and explain_button and has_api_key:
+            explainer = initialize_gemini_explainer()
+            if explainer:  # Verificar que el explainer se inicializó correctamente
+                try:
+                    with st.spinner("Generando explicación..."):
+                        model_info = {
+                            'name': model_name,
+                            'problem_type': problem_type,
+                            'hyperparameters': results.get('hyperparameters', 'N/A'),
+                            'performance_metric': results.get('test_accuracy', results.get('test_r2', 'N/A')),
+                            'training_time': results.get('training_time', 'N/A')
+                        }
+
+                        explanation = explainer.generate_model_explanation(model_info)
+                        
+                        # Almacenar explicación
+                        st.session_state.model_explanations[model_name] = explanation
+                        
+                        # Mostrar explicación
+                        st.markdown(explanation)
+                except Exception as e:
+                    st.error(f"Error al generar la explicación: {str(e)}")
+            else:
+                st.error("No se pudo inicializar el explicador de Gemini")
+
+        # Sección de análisis SHAP
+        st.write("---")
+        st.write("### Análisis SHAP")
+        
+        if st.button("Mostrar Análisis SHAP", key=f"shap_button_{model_name}"):
+            try:
+                # Obtener datos preparados
+                X = st.session_state.prepared_data[st.session_state.feature_cols]
+                
+                # Crear dashboard de análisis SHAP
+                create_shap_analysis_dashboard(
+                    results['best_model'],  # Usar el mejor modelo
+                    X, 
+                    problem_type
+                )
+            except Exception as e:
+                st.error(f"Error en el análisis SHAP: {str(e)}")
+
+        # Sección de descarga del modelo
+        st.write("---")
+        st.write("### Descarga del modelo")
+        
+        # Generar nombre de archivo
+        model_file_key = f"model_file_{model_name}"
+        if model_file_key not in st.session_state:
+            st.session_state[model_file_key] = f"{model_name.lower().replace(' ', '_')}_{int(time.time())}.pkl"
+        
+        # Input para nombre de archivo
+        model_name_input = st.text_input(
+            "Nombre del archivo:",
+            value=st.session_state[model_file_key],
+            key=f"name_input_{model_name}"
+        )
+        # Botón de descarga
+        model_buffer = io.BytesIO()
+        pickle.dump(results['best_model'], model_buffer)  # Guardar el mejor modelo
+        model_buffer.seek(0)
+        
+        download_key = f"download_{model_name}"
+        st.download_button(
+            label="Descargar Modelo",
+            data=model_buffer,
+            file_name=model_name_input,
+            mime="application/octet-stream",
+            key=download_key
+        )
+
+        # # Botón de descarga
+        # modelo_data = descargar_modelo_h2o(results['best_model'], model_name)
+        # if modelo_data:
+        #     st.download_button(
+        #         label="Descargar Modelo",
+        #         data=modelo_data,
+        #         file_name=model_name_input,
+        #         mime="application/zip",
+        #         key=f"download_{model_name}"
+        #     )

models/unsupervised.py

@@ -0,0 +1,585 @@
+# unsupervised.py - Módulo para models
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering
+from sklearn.manifold import TSNE
+from sklearn.metrics import silhouette_score, calinski_harabasz_score, davies_bouldin_score
+import google.generativeai as genai
+import umap
+
+class UnsupervisedAnalyzer:
+    def __init__(self, data):
+        self.data = data
+        self.scaler = StandardScaler()
+
+    def preprocess_data(self, feature_cols):
+        """Escalar datos seleccionados"""
+        X = self.data[feature_cols]
+        return self.scaler.fit_transform(X)
+
+    def perform_kmeans(self, X_scaled, n_clusters):
+        """Realizar clustering K-Means"""
+        kmeans = KMeans(
+            n_clusters=n_clusters, 
+            random_state=42, 
+            n_init=10
+        )
+        clusters = kmeans.fit_predict(X_scaled)
+
+        # Calcular métricas
+        metrics = {
+            'Silhouette Score': silhouette_score(X_scaled, clusters),
+            'Calinski-Harabasz Score': calinski_harabasz_score(X_scaled, clusters),
+            'Davies-Bouldin Score': davies_bouldin_score(X_scaled, clusters)
+        }
+
+        return {
+            'clusters': clusters,
+            'metrics': metrics,
+            'centroids': kmeans.cluster_centers_
+        }
+
+    def perform_dbscan(self, X_scaled, eps, min_samples):
+        """Realizar clustering DBSCAN"""
+        dbscan = DBSCAN(eps=eps, min_samples=min_samples)
+        clusters = dbscan.fit_predict(X_scaled)
+
+        # Calcular métricas
+        unique_clusters = np.setdiff1d(np.unique(clusters), [-1])
+        metrics = {
+            'Noise Points': np.sum(clusters == -1),
+            'Number of Clusters': len(unique_clusters)
+        }
+
+        # Solo calcular métricas si hay clusters válidos
+        if len(unique_clusters) > 0:
+            non_noise_mask = clusters != -1
+            metrics.update({
+                'Silhouette Score': silhouette_score(X_scaled[non_noise_mask], clusters[non_noise_mask]),
+                'Calinski-Harabasz Score': calinski_harabasz_score(X_scaled[non_noise_mask], clusters[non_noise_mask]),
+                'Davies-Bouldin Score': davies_bouldin_score(X_scaled[non_noise_mask], clusters[non_noise_mask])
+            })
+        else:
+            metrics.update({
+                'Silhouette Score': None,
+                'Calinski-Harabasz Score': None,
+                'Davies-Bouldin Score': None
+            })
+
+        return {
+            'clusters': clusters,
+            'metrics': metrics
+        }
+
+    def perform_hierarchical_clustering(self, X_scaled, n_clusters):
+        """Realizar clustering jerárquico"""
+        hierarchical = AgglomerativeClustering(n_clusters=n_clusters)
+        clusters = hierarchical.fit_predict(X_scaled)
+
+        # Calcular métricas
+        metrics = {
+            'Silhouette Score': silhouette_score(X_scaled, clusters),
+            'Calinski-Harabasz Score': calinski_harabasz_score(X_scaled, clusters),
+            'Davies-Bouldin Score': davies_bouldin_score(X_scaled, clusters)
+        }
+
+        return {
+            'clusters': clusters,
+            'metrics': metrics
+        }
+
+    def perform_dimensionality_reduction(self, X_scaled, method='PCA', n_components=2):
+        """Realizar reducción de dimensionalidad"""
+        if method == 'PCA':
+            reducer = PCA(n_components=n_components)
+            reduced_data = reducer.fit_transform(X_scaled)
+            return {
+                'reduced_data': reduced_data,
+                'explained_variance': reducer.explained_variance_ratio_
+            }
+        elif method == 't-SNE':
+            reducer = TSNE(n_components=n_components, random_state=42)
+            reduced_data = reducer.fit_transform(X_scaled)
+            return {
+                'reduced_data': reduced_data
+            }
+        elif method == 'UMAP':
+            reducer = umap.UMAP(n_components=n_components, random_state=42)
+            reduced_data = reducer.fit_transform(X_scaled)
+            return {
+                'reduced_data': reduced_data
+            }
+
+def generate_method_explanation(method, parameters, metrics):
+    """Generar explicación del método usando Gemini"""
+    try:
+        genai.configure(api_key=st.session_state.gemini_api_key)
+        model = genai.GenerativeModel('gemini-1.5-flash')
+
+        # Preparar prompt basado en el método
+        prompt = f"""Explica detalladamente el método de análisis no supervisado: {method}
+
+        Parámetros:
+        {', '.join([f"{k}: {v}" for k, v in parameters.items()])}
+
+        Métricas:
+        {', '.join([f"{k}: {v}" for k, v in metrics.items()])}
+
+        En tu explicación, incluye:
+        1. Objetivo principal del método
+        2. Cómo funciona el algoritmo
+        3. Interpretación de los parámetros
+        4. Significado de las métricas
+        5. Casos de uso recomendados"""
+
+        response = model.generate_content(prompt)
+        return response.text
+    except Exception as e:
+        return f"Error al generar explicación: {str(e)}"
+
+def visualize_clustering(X_scaled, clusters, method_name, n_components=2):
+    """Visualización de clustering"""
+    reducer = PCA(n_components=n_components)
+    X_reduced = reducer.fit_transform(X_scaled)
+    
+    if n_components == 2:
+        fig = px.scatter(
+            x=X_reduced[:, 0], 
+            y=X_reduced[:, 1],
+            color=clusters.astype(str),
+            title=f'Clustering {method_name} - Visualización PCA',
+            labels={'x': 'PCA Componente 1', 'y': 'PCA Componente 2'}
+        )
+    else:
+        fig = go.Figure(data=[
+            go.Scatter3d(
+                x=X_reduced[:, 0],
+                y=X_reduced[:, 1],
+                z=X_reduced[:, 2],
+                mode='markers',
+                marker=dict(
+                    size=5,
+                    color=clusters,
+                    colorscale='Viridis',
+                    opacity=0.8
+                )
+            )
+        ])
+        fig.update_layout(
+            title=f'Clustering {method_name} - Visualización 3D',
+            scene=dict(
+                xaxis_title='PCA 1',
+                yaxis_title='PCA 2', 
+                zaxis_title='PCA 3'
+            )
+        )
+    
+    return fig
+
+def show_unsupervised_analysis():
+    st.title("Análisis No Supervisado")
+
+    # Verificar datos preparados
+    if 'prepared_data' not in st.session_state or st.session_state.prepared_data is None:
+        st.warning("Por favor, carga y prepara tus datos primero")
+        return
+
+    # Obtener datos
+    data = st.session_state.prepared_data
+
+    # Seleccionar columnas numéricas
+    numeric_cols = data.select_dtypes(include=['int64', 'float64']).columns.tolist()
+
+    if not numeric_cols:
+        st.error("No hay variables numéricas para análisis no supervisado")
+        return
+
+    # Selección de características
+    feature_cols = st.multiselect(
+        "Seleccionar Variables para Análisis", 
+        numeric_cols, 
+        default=numeric_cols[:min(5, len(numeric_cols))]
+    )
+
+    if not feature_cols:
+        st.warning("Selecciona al menos una variable")
+        return
+
+    # Inicializar analizador
+    analyzer = UnsupervisedAnalyzer(data)
+    X_scaled = analyzer.preprocess_data(feature_cols)
+
+    # Selección de métodos
+    methods = st.multiselect(
+        "Seleccionar Métodos de Análisis",
+        [
+            "K-Means", 
+            "DBSCAN", 
+            "Clustering Jerárquico", 
+            "PCA", 
+            "t-SNE", 
+            "UMAP"
+        ]
+    )
+
+    # Contenedor para resultados
+    results = {}
+
+    # Columnas para visualización
+    if methods:
+        cols = st.columns(len(methods))
+
+        for i, method in enumerate(methods):
+            with cols[i]:
+                st.subheader(method)
+
+                # Parámetros específicos por método
+                if method == "K-Means":
+                    n_clusters = st.slider(
+                        "Número de Clusters", 
+                        min_value=2, 
+                        max_value=10, 
+                        value=3, 
+                        key=f"kmeans_clusters_{i}"
+                    )
+                    result = analyzer.perform_kmeans(X_scaled, n_clusters)
+                    results['K-Means'] = result
+
+                    # Visualización
+                    fig = visualize_clustering(X_scaled, result['clusters'], method)
+                    st.plotly_chart(fig)
+
+                    # Métricas
+                    st.write("Métricas:")
+                    for metric, value in result['metrics'].items():
+                        st.metric(metric, f"{value:.4f}")
+
+                    # Explicación con Gemini
+                    if st.session_state.get('gemini_api_key'):
+                        explanation = generate_method_explanation(
+                            method, 
+                            {'Número de Clusters': n_clusters}, 
+                            result['metrics']
+                        )
+                        with st.expander("Explicación del Método"):
+                            st.markdown(explanation)
+
+                elif method == "DBSCAN":
+                    eps = st.slider(
+                        "Epsilon", 
+                        min_value=0.1, 
+                        max_value=2.0, 
+                        value=0.5, 
+                        key=f"dbscan_eps_{i}"
+                    )
+                    min_samples = st.slider(
+                        "Mínimo de Muestras", 
+                        min_value=2, 
+                        max_value=20, 
+                        value=5, 
+                        key=f"dbscan_min_samples_{i}"
+                    )
+                    result = analyzer.perform_dbscan(X_scaled, eps, min_samples)
+                    results['DBSCAN'] = result
+
+                    # Visualización
+                    fig = visualize_clustering(X_scaled, result['clusters'], method)
+                    st.plotly_chart(fig)
+
+                    # Métricas
+                    st.write("Métricas:")
+                    for metric, value in result['metrics'].items():
+                        st.metric(metric, str(value))
+
+                    # Explicación con Gemini
+                    if st.session_state.get('gemini_api_key'):
+                        explanation = generate_method_explanation(
+                            method, 
+                            {
+                                'Epsilon': eps, 
+                                'Mínimo de Muestras': min_samples
+                            }, 
+                            result['metrics']
+                        )
+                        with st.expander("Explicación del Método"):
+                            st.markdown(explanation)
+
+                elif method == "Clustering Jerárquico":
+                    n_clusters = st.slider(
+                        "Número de Clusters", 
+                        min_value=2, 
+                        max_value=10, 
+                        value=3, 
+                        key=f"hierarchical_clusters_{i}"
+                    )
+                    result = analyzer.perform_hierarchical_clustering(X_scaled, n_clusters)
+                    results['Clustering Jerárquico'] = result
+
+                    # Visualización
+                    fig = visualize_clustering(X_scaled, result['clusters'], method)
+                    st.plotly_chart(fig)
+
+                    # Métricas
+                    st.write("Métricas:")
+                    for metric, value in result['metrics'].items():
+                        st.metric(metric, f"{value:.4f}")
+
+                    # Explicación con Gemini
+                    if st.session_state.get('gemini_api_key'):
+                        explanation = generate_method_explanation(
+                            method, 
+                            {'Número de Clusters': n_clusters}, 
+                            result['metrics']
+                        )
+                        with st.expander("Explicación del Método"):
+                            st.markdown(explanation)
+
+                elif method in ["PCA", "t-SNE", "UMAP"]:
+                    n_components = st.slider(
+                        "Número de Componentes", 
+                        min_value=2, 
+                        max_value=3, 
+                        value=2, 
+                        key=f"{method}_components_{i}"
+                    )
+                    result = analyzer.perform_dimensionality_reduction(
+                        X_scaled, 
+                        method=method, 
+                        n_components=n_components
+                    )
+                    results[method] = result
+
+                    # Visualización de reducción de dimensionalidad
+                    fig = px.scatter(
+                        x=result['reduced_data'][:, 0],
+                        y=result['reduced_data'][:, 1],
+                        title=f'Reducción de Dimensionalidad - {method}'
+                    )
+                    st.plotly_chart(fig)
+
+                    # Varianza explicada para PCA
+                    if method == 'PCA':
+                        st.write("Varianza Explicada:")
+                        varianza_df = pd.DataFrame({
+                            'Componente': range(1, len(result['explained_variance']) + 1),
+                            'Varianza Explicada (%)': result['explained_variance'] * 100,
+                            'Varianza Acumulada (%)': np.cumsum(result['explained_variance']) * 100
+                        })
+                        st.dataframe(varianza_df)
+
+                    # Explicación con Gemini
+                    if st.session_state.get('gemini_api_key'):
+                        explanation = generate_method_explanation(
+                            method, 
+                            {'Número de Componentes': n_components}, 
+                            {}
+                        )
+                        with st.expander("Explicación del Método"):
+                            st.markdown(explanation)
+
+        # Exportar resultados
+        if st.button("Exportar Resultados"):
+            export_data = []
+            for method, result in results.items():
+                method_data = {
+                    'Método': method,
+                    'Variables': ', '.join(feature_cols)
+                }
+                
+                # Agregar métricas si están disponibles
+                if 'metrics' in result:
+                    method_data.update(result['metrics'])
+                
+                export_data.append(method_data)
+            
+            export_df = pd.DataFrame(export_data)
+            csv = export_df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="Descargar Resultados",
+                data=csv,
+                file_name="unsupervised_analysis_results.csv",
+                mime="text/csv",
+                key="download_unsupervised_results"
+            )
+
+def show_unsupervised():
+    """Función principal para mostrar la página de análisis no supervisado"""
+    st.title("🔍 Análisis No Supervisado")
+
+    # Verificar datos preparados
+    if 'prepared_data' not in st.session_state or st.session_state.prepared_data is None:
+        st.warning("Por favor, carga y prepara tus datos primero en la página de Preparación.")
+        return
+
+    # Obtener datos preparados
+    data = st.session_state.prepared_data
+
+    # Sección de selección de variables
+    st.header("Configuración del Análisis")
+
+    # Seleccionar columnas numéricas
+    numeric_cols = data.select_dtypes(include=['int64', 'float64']).columns.tolist()
+
+    if not numeric_cols:
+        st.error("No hay variables numéricas disponibles para realizar análisis no supervisado.")
+        return
+
+    # Selección de características
+    st.subheader("Selección de Variables")
+    feature_cols = st.multiselect(
+        "Selecciona las variables para el análisis", 
+        numeric_cols, 
+        default=numeric_cols[:min(5, len(numeric_cols))]
+    )
+
+    if not feature_cols:
+        st.warning("Por favor, selecciona al menos una variable.")
+        return
+
+    # Inicializar analizador
+    analyzer = UnsupervisedAnalyzer(data)
+    X_scaled = analyzer.preprocess_data(feature_cols)
+
+    # Sección de métodos de análisis
+    st.header("Métodos de Análisis")
+
+    # Selección de métodos
+    metodos = st.multiselect(
+        "Elige los métodos de análisis no supervisado",
+        [
+            "K-Means", 
+            "DBSCAN", 
+            "Clustering Jerárquico", 
+            "Análisis de Componentes Principales (PCA)", 
+            "t-SNE", 
+            "UMAP"
+        ]
+    )
+
+    # Contenedor de resultados
+    resultados = {}
+
+    # Procesamiento de métodos seleccionados
+    if metodos:
+        # Crear columnas dinámicamente
+        cols = st.columns(len(metodos))
+
+        for i, metodo in enumerate(metodos):
+            with cols[i]:
+                st.subheader(metodo)
+
+                # Parámetros específicos por método
+                if metodo == "K-Means":
+                    n_clusters = st.slider(
+                        "Número de Clusters", 
+                        min_value=2, 
+                        max_value=10, 
+                        value=3, 
+                        key=f"kmeans_clusters_{i}"
+                    )
+                    
+                    # Realizar K-Means
+                    resultado = analyzer.perform_kmeans(X_scaled, n_clusters)
+                    resultados[metodo] = resultado
+
+                    # Visualización
+                    fig = visualize_clustering(X_scaled, resultado['clusters'], metodo)
+                    st.plotly_chart(fig)
+
+                    # Mostrar métricas
+                    st.subheader("Métricas")
+                    for metrica, valor in resultado['metrics'].items():
+                        st.metric(metrica, f"{valor:.4f}")
+
+                    # Explicación con Gemini
+                    if st.session_state.get('gemini_api_key'):
+                        explicacion = generate_method_explanation(
+                            metodo, 
+                            {'Número de Clusters': n_clusters}, 
+                            resultado['metrics']
+                        )
+                        with st.expander("Explicación del Método"):
+                            st.markdown(explicacion)
+
+                elif metodo == "DBSCAN":
+                    eps = st.slider(
+                        "Epsilon", 
+                        min_value=0.1, 
+                        max_value=2.0, 
+                        value=0.5, 
+                        key=f"dbscan_eps_{i}"
+                    )
+                    min_samples = st.slider(
+                        "Mínimo de Muestras", 
+                        min_value=2, 
+                        max_value=20, 
+                        value=5, 
+                        key=f"dbscan_min_samples_{i}"
+                    )
+
+                    # Realizar DBSCAN
+                    resultado = analyzer.perform_dbscan(X_scaled, eps, min_samples)
+                    resultados[metodo] = resultado
+
+                    # Visualización
+                    fig = visualize_clustering(X_scaled, resultado['clusters'], metodo)
+                    st.plotly_chart(fig)
+
+                    # Mostrar métricas
+                    st.subheader("Métricas")
+                    for metrica, valor in resultado['metrics'].items():
+                        st.metric(metrica, str(valor))
+
+                    # Explicación con Gemini
+                    if st.session_state.get('gemini_api_key'):
+                        explicacion = generate_method_explanation(
+                            metodo, 
+                            {
+                                'Epsilon': eps, 
+                                'Mínimo de Muestras': min_samples
+                            }, 
+                            resultado['metrics']
+                        )
+                        with st.expander("Explicación del Método"):
+                            st.markdown(explicacion)
+
+                # Continuar con los demás métodos de manera similar...
+
+        # Sección de exportación de resultados
+        if st.button("Exportar Resultados del Análisis"):
+            # Crear DataFrame con resultados
+            datos_exportacion = []
+            for metodo, resultado in resultados.items():
+                datos_metodo = {
+                    'Método': metodo,
+                    'Variables': ', '.join(feature_cols)
+                }
+                
+                # Agregar métricas si están disponibles
+                if 'metrics' in resultado:
+                    datos_metodo.update(resultado['metrics'])
+                
+                datos_exportacion.append(datos_metodo)
+            
+            df_exportacion = pd.DataFrame(datos_exportacion)
+            
+            # Descargar CSV
+            csv = df_exportacion.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="Descargar Resultados",
+                data=csv,
+                file_name="analisis_no_supervisado.csv",
+                mime="text/csv"
+            )
+
+# Función principal para ejecutar el análisis no supervisado
+def main():
+    show_unsupervised()
+
+if __name__ == "__main__":
+    main()

packages.txt

@@ -0,0 +1,2 @@
+libsnappy-dev
+libgl1

requirements.txt

@@ -0,0 +1,24 @@
+streamlit_option_menu
+streamlit_lottie
+pandas
+numpy
+scikit-learn==1.4.0
+google-generativeai
+plotly
+supabase
+python-dotenv
+shap
+xgboost
+requests
+typing
+streamlit_shap
+matplotlib
+pyarrow
+umap
+imblearn
+openpyxl
+pygwalker
+ydata_profiling
+stqdm
+h2o
+FLAML

utils/__init__.py

@@ -0,0 +1,2 @@
+# __init__.py - M�dulo para src utils
+from .model_utils import ModelTrainer

utils/gemini_explainer.py

@@ -0,0 +1,438 @@
+# utils/gemini_explainer.py
+import streamlit as st
+import google.generativeai as genai
+from typing import Dict, Any, Optional
+import h2o
+import os
+
+def generate_dataset_explanation(dataset, api_key=None):
+    """
+    Generate a dataset explanation using Gemini AI
+    
+    Args:
+        dataset (pd.DataFrame): DataFrame to explain
+        api_key (str, optional): Gemini API key
+    
+    Returns:
+        str: Explanation of the dataset
+    """
+    try:
+        # Prepare dataset information
+        dataset_info = {
+            'rows': len(dataset),
+            'columns': len(dataset.columns),
+            'column_names': list(dataset.columns),
+            'data_types': str(dataset.dtypes),
+            'first_rows': dataset.head().to_string(),
+            'basic_stats': dataset.describe().to_string()
+        }
+        
+        # Initialize Gemini Explainer
+        explainer = GeminiExplainer(api_key)
+        
+        # Generate explanation
+        explanation = explainer.generate_dataset_explanation(dataset_info)
+        
+        return explanation
+    
+    except Exception as e:
+        return f"Error generating dataset explanation: {str(e)}"
+    
+def generate_model_explanation(self, model_info: Dict[str, Any]) -> str:
+        """
+        Generar una explicación detallada de un modelo de machine learning
+        
+        Args:
+            model_info (dict): Información del modelo
+        
+        Returns:
+            str: Explicación generada por Gemini
+        """
+        prompt = f"""Proporciona una explicación detallada del modelo de machine learning:
+
+        Información del Modelo:
+        - Nombre del Modelo: {model_info.get('name', 'N/A')}
+        - Tipo de Problema: {model_info.get('problem_type', 'N/A')}
+        - Hiperparámetros: {model_info.get('hyperparameters', 'N/A')}
+        - Métricas de Rendimiento:
+            * Accuracy/R²: {model_info.get('performance_metric', 'N/A')}
+            * Otras métricas: {model_info.get('additional_metrics', 'N/A')}
+
+        En tu explicación, incluye:
+        1. Descripción del algoritmo
+        2. Funcionamiento interno del modelo
+        3. Interpretación de los hiperparámetros
+        4. Análisis de las métricas de rendimiento
+        5. Fortalezas y limitaciones del modelo
+        6. Recomendaciones para posibles mejoras"""
+
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            return f"Error al generar explicación: {str(e)}"
+        
+class GeminiExplainer:
+    def __init__(self, api_key: Optional[str] = None):
+        """
+        Inicializar el explicador de Gemini
+        
+        Args:
+            api_key (str, opcional): API key de Google Generative AI
+        """
+        self.api_key = api_key or st.session_state.get('gemini_api_key')
+        
+        if not self.api_key:
+            raise ValueError("No se ha proporcionado una API key de Gemini")
+        
+        # Configurar la API de Gemini
+        genai.configure(api_key=self.api_key)
+        
+        # Seleccionar modelo
+        self.model = genai.GenerativeModel('gemini-1.5-flash')
+
+    def generate_dataset_explanation(self, dataset_info: Dict[str, Any]) -> str:
+        """
+        Generar una explicación detallada del dataset
+        
+        Args:
+            dataset_info (dict): Información del dataset
+        
+        Returns:
+            str: Explicación generada por Gemini
+        """
+        prompt = f"""Analiza este dataset y proporciona una explicación clara y concisa de su estructura y contenido:
+
+        Información del Dataset:
+        - Dimensiones: {dataset_info.get('rows', 'N/A')} filas × {dataset_info.get('columns', 'N/A')} columnas
+        - Columnas: {', '.join(dataset_info.get('column_names', []))}
+        - Tipos de datos: {dataset_info.get('data_types', 'N/A')}
+        - Primeras filas: {dataset_info.get('first_rows', 'N/A')}
+        - Estadísticas básicas: {dataset_info.get('basic_stats', 'N/A')}
+
+        En tu explicación, incluye:
+        1. Descripción general del dataset
+        2. Tipos de variables presentes
+        3. Posibles desafíos o consideraciones para el análisis
+        4. Sugerencias iniciales de preprocesamiento
+        5. Potenciales insights o patrones preliminares"""
+
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            return f"Error al generar explicación: {str(e)}"
+
+    def generate_model_explanation(self, model_info: Dict[str, Any]) -> str:
+        """
+        Generar una explicación detallada de un modelo de machine learning
+        
+        Args:
+            model_info (dict): Información del modelo
+        
+        Returns:
+            str: Explicación generada por Gemini
+        """
+        # Extraer hiperparámetros en formato legible
+        hyperparameters = model_info.get('hyperparameters', {})
+        if isinstance(hyperparameters, dict):
+            hyperparams_str = "\n".join([f"- {k}: {v}" for k, v in hyperparameters.items()])
+        else:
+            hyperparams_str = str(hyperparameters)
+        
+        prompt = f"""Proporciona una explicación detallada del modelo de machine learning:
+
+Información del Modelo:
+- Nombre del Modelo: {model_info.get('name', 'N/A')}
+- Tipo de Problema: {model_info.get('problem_type', 'N/A')}
+- Hiperparámetros: 
+{hyperparams_str}
+- Métricas de Rendimiento:
+    * Accuracy/R²: {model_info.get('performance_metric', 'N/A')}
+    * Tiempo de Entrenamiento: {model_info.get('training_time', 'N/A')}
+
+En tu explicación, incluye:
+1. Descripción del algoritmo
+2. Funcionamiento interno del modelo
+3. Interpretación de los hiperparámetros
+4. Análisis de las métricas de rendimiento
+5. Fortalezas y limitaciones del modelo
+6. Recomendaciones para posibles mejoras"""
+
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            return f"Error al generar explicación: {str(e)}"
+
+    def generate_clustering_explanation(self, clustering_info: Dict[str, Any]) -> str:
+        """
+        Generar una explicación de resultados de clustering
+        
+        Args:
+            clustering_info (dict): Información del clustering
+        
+        Returns:
+            str: Explicación generada por Gemini
+        """
+        prompt = f"""Analiza los resultados del método de clustering:
+
+Información del Clustering:
+- Método: {clustering_info.get('method', 'N/A')}
+- Número de Clusters: {clustering_info.get('n_clusters', 'N/A')}
+- Parámetros: {clustering_info.get('parameters', 'N/A')}
+- Métricas:
+    * Silhouette Score: {clustering_info.get('silhouette_score', 'N/A')}
+    * Calinski-Harabasz: {clustering_info.get('calinski_score', 'N/A')}
+    * Davies-Bouldin: {clustering_info.get('davies_bouldin', 'N/A')}
+
+En tu explicación, incluye:
+1. Descripción del método de clustering
+2. Interpretación de los parámetros utilizados
+3. Significado de las métricas de evaluación
+4. Análisis de la calidad de los clusters
+5. Posibles insights o patrones detectados
+6. Recomendaciones para ajustar el clustering"""
+
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            return f"Error al generar explicación: {str(e)}"
+
+    def generate_feature_importance_explanation(self, feature_importance_info: Dict[str, Any]) -> str:
+        """
+        Generar una explicación de la importancia de características
+        
+        Args:
+            feature_importance_info (dict): Información de importancia de características
+        
+        Returns:
+            str: Explicación generada por Gemini
+        """
+        method = feature_importance_info.get('method', 'N/A')
+        features = feature_importance_info.get('features', [])
+        importance_values = feature_importance_info.get('importance_values', {})
+        
+        # Formatear la información de importancia
+        importance_str = "\n".join([f"- {feat}: {val}" for feat, val in importance_values.items()])
+        
+        prompt = f"""Analiza la importancia de las características en el modelo:
+
+Información de Importancia de Características:
+- Método de Evaluación: {method}
+- Características:
+{importance_str}
+
+En tu explicación, incluye:
+1. Descripción del método de evaluación de importancia
+2. Análisis de las características más importantes
+3. Interpretación de los valores de importancia
+4. Posibles implicaciones para el modelado
+5. Recomendaciones para selección de características"""
+
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            return f"Error al generar explicación: {str(e)}"
+
+def initialize_gemini_explainer():
+    """
+    Función de utilidad para inicializar el explicador de Gemini en Streamlit
+    
+    Returns:
+        GeminiExplainer: Instancia del explicador de Gemini o None si hay error
+    """
+    try:
+        if 'gemini_api_key' not in st.session_state:
+            st.warning("Por favor configura tu API key de Gemini primero")
+            return None
+            
+        api_key = st.session_state.get('gemini_api_key')
+        if not api_key:
+            st.warning("API key de Gemini no encontrada")
+            return None
+            
+        # Inicializar explicador con la API key
+        explainer = GeminiExplainer(api_key=api_key)
+        return explainer
+        
+    except Exception as e:
+        st.error(f"Error al inicializar el explicador: {str(e)}")
+        return None
+    
+# Ejemplo de uso en Streamlit
+def main():
+    st.title("Explicaciones con Gemini")
+
+    # Verificar configuración de API key
+    if 'gemini_api_key' not in st.session_state:
+        st.warning("Configura tu API key de Gemini")
+        return
+
+    explainer = initialize_gemini_explainer()
+    
+    if explainer:
+        # Ejemplo de uso de métodos de explicación
+        st.subheader("Explicación de Dataset")
+        dataset_info = {
+            'rows': 100,
+            'columns': 5,
+            'column_names': ['age', 'income', 'education', 'credit_score', 'loan_approved'],
+            'data_types': 'Mixed (numeric and categorical)',
+            'first_rows': 'Sample data preview',
+            'basic_stats': 'Mean, median, standard deviation'
+        }
+        
+        if st.button("Explicar Dataset"):
+            explanation = explainer.generate_dataset_explanation(dataset_info)
+            st.markdown(explanation)
+
+        st.subheader("Explicación de Modelo")
+        model_info = {
+            'name': 'Random Forest Classifier',
+            'problem_type': 'Clasificación binaria',
+            'hyperparameters': {
+                'n_estimators': 100,
+                'max_depth': 5,
+                'learning_rate': 0.1
+            },
+            'performance_metric': 0.85,
+            'additional_metrics': {
+                'precision': 0.82,
+                'recall': 0.88,
+                'f1_score': 0.85
+            }
+        }
+
+        if st.button("Explicar Modelo"):
+            explanation = explainer.generate_model_explanation(model_info)
+            st.markdown(explanation)
+
+        st.subheader("Explicación de Clustering")
+        clustering_info = {
+            'method': 'K-Means',
+            'n_clusters': 3,
+            'parameters': {
+                'eps': 0.5,
+                'min_samples': 5
+            },
+            'silhouette_score': 0.7,
+            'calinski_score': 150.5,
+            'davies_bouldin': 0.4
+        }
+
+        if st.button("Explicar Clustering"):
+            explanation = explainer.generate_clustering_explanation(clustering_info)
+            st.markdown(explanation)
+
+        st.subheader("Explicación de Importancia de Características")
+        feature_importance_info = {
+            'method': 'SHAP Values',
+            'features': ['age', 'income', 'education', 'credit_score'],
+            'importance_values': {
+                'age': 0.35,
+                'income': 0.25,
+                'education': 0.2,
+                'credit_score': 0.2
+            }
+        }
+
+        if st.button("Explicar Importancia de Características"):
+            explanation = explainer.generate_feature_importance_explanation(feature_importance_info)
+            st.markdown(explanation)
+
+# Función para manejar errores de API key
+def validate_gemini_api_key(api_key: str) -> bool:
+    """
+    Validar la API key de Gemini
+    
+    Args:
+        api_key (str): API key a validar
+    
+    Returns:
+        bool: True si la API key es válida, False en caso contrario
+    """
+    try:
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-1.5-flash')
+        # Intentar generar una respuesta simple
+        response = model.generate_content("Hola, ¿estás funcionando?")
+        return True
+    except Exception as e:
+        st.error(f"Error de validación de API key: {str(e)}")
+        return False
+
+# Función de configuración de API key en Streamlit
+def setup_gemini_api_key():
+    """
+    Configurar y validar la API key de Gemini en Streamlit
+    """
+    st.sidebar.header("🔑 Configuración de Gemini API")
+    
+    # Input para la API key
+    api_key = st.sidebar.text_input(
+        "Ingresa tu Gemini API Key", 
+        type="password",
+        help="Puedes obtener tu API key en Google AI Studio"
+    )
+    
+    # Botón de validación
+    if st.sidebar.button("Validar API Key"):
+        if api_key:
+            if validate_gemini_api_key(api_key):
+                st.session_state.gemini_api_key = api_key
+                st.sidebar.success("✅ API Key validada correctamente")
+            else:
+                st.sidebar.error("❌ API Key inválida")
+        else:
+            st.sidebar.warning("Por favor, ingresa una API Key")
+    
+    # Mostrar estado actual
+    if 'gemini_api_key' in st.session_state:
+        st.sidebar.info("API Key configurada")
+
+# Configuraciones adicionales y documentación
+def get_gemini_documentation():
+    """
+    Generar documentación sobre el uso de Gemini en el proyecto
+    
+    Returns:
+        str: Documentación en formato markdown
+    """
+    documentation = """
+    ## 🤖 Explicaciones con Gemini AI
+
+    ### Características
+    - Generación de explicaciones detalladas para:
+      * Datasets
+      * Modelos de Machine Learning
+      * Resultados de Clustering
+      * Importancia de Características
+
+    ### Requisitos
+    - API Key de Google AI Studio
+    - Conexión a internet
+    - Biblioteca `google-generativeai`
+
+    ### Configuración
+    1. Obtén tu API Key en [Google AI Studio](https://makersuite.google.com/app/apikey)
+    2. Configura la API Key en la barra lateral
+    3. Valida la conexión con el botón "Validar API Key"
+
+    ### Limitaciones
+    - Depende de la disponibilidad del servicio
+    - Consumo de tokens de API
+    - Explicaciones generadas por IA pueden no ser 100% precisas
+
+    ### Mejores Prácticas
+    - Usar como complemento, no como única fuente de verdad
+    - Verificar siempre las explicaciones generadas
+    - Tener contexto del problema al interpretar resultados
+    """
+    return documentation
+
+# Punto de entrada principal
+if __name__ == "__main__":
+    main()

utils/model_utils.py

@@ -0,0 +1,606 @@
+# utils/models_utils.py
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import time
+import pickle
+import io
+from stqdm import stqdm
+from sklearn.model_selection import GridSearchCV, train_test_split
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.linear_model import (
+    LinearRegression, LogisticRegression, Lasso, Ridge,
+    SGDClassifier, RidgeClassifier, PassiveAggressiveClassifier
+)
+from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier
+from sklearn.ensemble import (
+    RandomForestRegressor, RandomForestClassifier,
+    GradientBoostingClassifier, AdaBoostClassifier,
+    BaggingClassifier, ExtraTreesClassifier, ExtraTreesRegressor
+)
+from sklearn.naive_bayes import GaussianNB, MultinomialNB, BernoulliNB
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.svm import SVC, SVR
+from sklearn.metrics import (
+    mean_squared_error, r2_score, mean_absolute_error,
+    accuracy_score, classification_report, confusion_matrix
+)
+from sklearn.base import BaseEstimator, ClassifierMixin, RegressorMixin
+import xgboost as xgb
+import h2o
+import os
+
+class ModelTrainer:
+    """
+    Clase para gestionar el entrenamiento de modelos de machine learning
+    """
+    @staticmethod
+    def get_model_options(problem_type):
+        """
+        Obtener opciones de modelos según el tipo de problema
+        
+        Args:
+            problem_type (str): Tipo de problema ('classification' o 'regression')
+        
+        Returns:
+            dict: Diccionario de opciones de modelos
+        """
+        if problem_type == 'regression':
+            return ModelTrainer._get_regression_models()
+        else:
+            return ModelTrainer._get_classification_models()
+
+    @staticmethod
+    def _get_regression_models():
+        """
+        Definir opciones de modelos para regresión
+        
+        Returns:
+            dict: Modelos de regresión con sus parámetros
+        """
+        return {
+            'Regresión Lineal': {
+                'model': lambda rs: Pipeline([
+                    ('scaler', StandardScaler()),
+                    ('regressor', LinearRegression())
+                ]),
+                'params': {
+                    'regressor__fit_intercept': [True, False],
+                    'regressor__copy_X': [True],
+                    'regressor__positive': [True, False],
+                    'scaler__with_mean': [True, False],
+                    'scaler__with_std': [True, False]
+                }
+            },
+            'Lasso': {
+                'model': lambda rs: Pipeline([
+                    ('scaler', StandardScaler()),
+                    ('regressor', Lasso(random_state=rs))
+                ]),
+                'params': {
+                    'regressor__alpha': [0.0001, 0.001, 0.01, 0.1, 1.0, 10.0],
+                    'regressor__fit_intercept': [True, False],
+                    'regressor__max_iter': [1000, 2000, 5000],
+                    'regressor__selection': ['cyclic', 'random'],
+                    'regressor__tol': [1e-4, 1e-3],
+                    'scaler__with_mean': [True, False],
+                    'scaler__with_std': [True, False]
+                }
+            },
+            'Ridge': {
+                'model': lambda rs: Pipeline([
+                    ('scaler', StandardScaler()),
+                    ('regressor', Ridge(random_state=rs))
+                ]),
+                'params': {
+                    'regressor__alpha': [0.0001, 0.001, 0.01, 0.1, 1.0, 10.0],
+                    'regressor__fit_intercept': [True, False],
+                    'regressor__solver': ['auto', 'svd', 'cholesky', 'lsqr', 'sparse_cg', 'sag', 'saga'],
+                    'regressor__tol': [1e-4, 1e-3],
+                    'scaler__with_mean': [True, False],
+                    'scaler__with_std': [True, False]
+                }
+            },
+            'Árbol de Decisión': {
+                'model': lambda rs: DecisionTreeRegressor(random_state=rs),
+                'params': {
+                    'max_depth': [3, 5, 7, 10, 15, None],
+                    'min_samples_split': [2, 5, 10, 20],
+                    'min_samples_leaf': [1, 2, 4, 8],
+                    'criterion': ['squared_error', 'friedman_mse', 'absolute_error', 'poisson'],
+                    'splitter': ['best', 'random'],
+                    'max_features': ['sqrt', 'log2', None]
+                }
+            },
+            'Random Forest': {
+                'model': lambda rs: RandomForestRegressor(random_state=rs),
+                'params': {
+                    'n_estimators': [100, 200, 300, 500],
+                    'max_depth': [3, 5, 7, 10, None],
+                    'min_samples_split': [2, 5, 10, 20],
+                    'min_samples_leaf': [1, 2, 4],
+                    'max_features': ['sqrt', 'log2', None],
+                    'bootstrap': [True, False],
+                    'criterion': ['squared_error', 'absolute_error', 'poisson']
+                }
+            },
+            'XGBoost': {
+                'model': lambda rs: xgb.XGBRegressor(
+                    tree_method='hist',
+                    device='cuda',
+                    enable_categorical=True,
+                    random_state=rs
+                ),
+                'params': {
+                    'n_estimators': [100, 200, 300, 500],
+                    'max_depth': [3, 5, 7, 9],
+                    'learning_rate': [0.01, 0.05, 0.1, 0.3],
+                    'subsample': [0.8, 0.9, 1.0],
+                    'colsample_bytree': [0.8, 0.9, 1.0],
+                    'min_child_weight': [1, 3, 5],
+                    'gamma': [0, 0.1, 0.2],
+                    'reg_alpha': [0, 0.1, 0.5],
+                    'reg_lambda': [0.1, 1.0, 5.0]
+                }
+            }
+        }
+
+    @staticmethod
+    def _get_classification_models():
+        """
+        Definir opciones de modelos para clasificación
+        
+        Returns:
+            dict: Modelos de clasificación con sus parámetros
+        """
+        return {
+            'Regresión Logística': {
+                'model': lambda rs: LogisticRegression(max_iter=1000, random_state=rs),
+                'params': {
+                    'C': [0.001, 0.01, 0.1, 1.0, 10.0],
+                    'penalty': ['l1', 'l2'],
+                    'solver': ['liblinear', 'saga'],
+                    'class_weight': [None, 'balanced'],
+                    'warm_start': [True, False],
+                    'tol': [1e-4, 1e-3, 1e-2]
+                }
+            },
+            'Random Forest': {
+                'model': lambda rs: RandomForestClassifier(random_state=rs),
+                'params': {
+                    'n_estimators': [100, 200, 300, 500],
+                    'max_depth': [3, 5, 7, 10, None],
+                    'min_samples_split': [2, 5, 10],
+                    'min_samples_leaf': [1, 2, 4],
+                    'class_weight': [None, 'balanced', 'balanced_subsample'],
+                    'criterion': ['gini', 'entropy'],
+                    'max_features': ['sqrt', 'log2', None]
+                }
+            },
+            'XGBoost': {
+                'model': lambda rs: xgb.XGBClassifier(
+                    tree_method='hist',
+                    device='cuda',
+                    enable_categorical=True,
+                    random_state=rs
+                ),
+                'params': {
+                    'n_estimators': [100, 200, 300, 500],
+                    'max_depth': [3, 5, 7, 9],
+                    'learning_rate': [0.01, 0.05, 0.1, 0.3],
+                    'subsample': [0.8, 0.9, 1.0],
+                    'colsample_bytree': [0.8, 0.9, 1.0],
+                    'min_child_weight': [1, 3, 5],
+                    'gamma': [0, 0.1, 0.2],
+                    'reg_alpha': [0, 0.1, 0.5],
+                    'reg_lambda': [0.1, 1.0, 5.0],
+                    'scale_pos_weight': [1, 2, 3]
+                }
+            },
+            'SVM': {
+                'model': lambda rs: SVC(random_state=rs),
+                'params': {
+                    'C': [0.1, 1, 10, 100],
+                    'kernel': ['linear', 'rbf', 'poly', 'sigmoid'],
+                    'gamma': ['scale', 'auto', 0.1, 0.01, 0.001],
+                    'class_weight': [None, 'balanced'],
+                    'probability': [True]
+                }
+            },
+            'Naive Bayes': {
+                'model': lambda rs: GaussianNB(),
+                'params': {
+                    'var_smoothing': [1e-9, 1e-8, 1e-7, 1e-6]
+                }
+            }
+        }
+
+    @staticmethod
+    def _determine_problem_type(model):
+        """
+        Determinar el tipo de problema basado en el modelo
+        
+        Args:
+            model (BaseEstimator): Modelo a evaluar
+        
+        Returns:
+            str: Tipo de problema ('classification', 'regression', 'unknown')
+        """
+        try:
+            if hasattr(model, 'predict_proba'):
+                return 'classification'
+            elif hasattr(model, 'predict'):
+                return 'regression'
+            else:
+                return 'unknown'
+        except ImportError:
+            return 'unknown'
+
+    @staticmethod
+    def _get_default_scoring(problem_type):
+        """
+        Obtener la métrica de scoring predeterminada
+        
+        Args:
+            problem_type (str): Tipo de problema
+        
+        Returns:
+            str: Métrica de scoring predeterminada
+        """
+        scoring_map = {
+            'classification': 'accuracy',
+            'regression': 'r2',
+            'unknown': None
+        }
+        return scoring_map.get(problem_type, None)
+
+    @staticmethod
+    def train_model_pipeline(
+        X_train, 
+        y_train, 
+        model_config, 
+        X_test=None, 
+        y_test=None, 
+        cv=5, 
+        scoring=None, 
+        random_state=42,  
+        **kwargs
+    ):
+        """
+        Entrenar modelo con validación cruzada y evaluación flexible
+        
+        Args:
+            X_train (array-like): Datos de entrenamiento
+            y_train (array-like): Etiquetas de entrenamiento
+            model_config (dict): Configuración del modelo
+            X_test (array-like, optional): Datos de prueba
+            y_test (array-like, optional): Etiquetas de prueba
+            cv (int, optional): Número de pliegues para validación cruzada
+            scoring (str, optional): Métrica de puntuación
+            random_state (int, optional): Semilla aleatoria para reproducibilidad
+            **kwargs: Argumentos adicionales
+        
+        Returns:
+            dict: Resultados detallados del entrenamiento
+        """
+        # Extraer modelo y parámetros
+        model_func = model_config.get('model')
+        params = model_config.get('params', {})
+
+        # Instanciar el modelo si es una función
+        if callable(model_func):
+            model = model_func(random_state)
+        else:
+            model = model_func
+
+        # Verificar que el modelo sea una instancia válida
+        if not hasattr(model, 'fit') or not hasattr(model, 'predict'):
+            raise ValueError(f"Modelo inválido: {model}. Debe tener métodos 'fit' y 'predict'.")
+
+        # Determinar tipo de problema
+        problem_type = ModelTrainer._determine_problem_type(model)
+        
+        # Configurar scoring
+        if scoring is None:
+            scoring = ModelTrainer._get_default_scoring(problem_type)
+
+        # Configurar parámetros de GridSearchCV
+        grid_search_params = {
+            'estimator': model,
+            'param_grid': params,
+            'cv': cv,
+            'scoring': scoring
+        }
+        
+        # Añadir kwargs adicionales
+        grid_search_params.update({
+            k: v for k, v in kwargs.items() 
+            if k in ['n_jobs', 'verbose', 'refit', 'error_score']
+        })
+
+        try:
+            # Realizar búsqueda de hiperparámetros
+            grid_search = GridSearchCV(**grid_search_params)
+            with st.spinner(f"Entrenando modelo {model}..."):
+                start_time = time.time()
+                grid_search.fit(X_train, y_train)
+                training_time = time.time() - start_time
+
+        except Exception as e:
+            return {
+                'error': f"Error durante el entrenamiento: {str(e)}",
+                'problem_type': problem_type
+            }
+
+        # Preparar resultados base
+        results = {
+            'problem_type': problem_type,
+            'best_model': grid_search.best_estimator_,
+            'best_params': grid_search.best_params_,
+            'best_score': grid_search.best_score_,
+            'cv_results': grid_search.cv_results_,
+            'training_time': training_time
+        }
+
+        # Evaluación en conjunto de prueba
+        if X_test is not None and y_test is not None:
+            best_model = grid_search.best_estimator_
+            y_pred = best_model.predict(X_test)
+            
+            # Métricas específicas según el tipo de problema
+            if problem_type == 'classification':
+                results.update({
+                    'test_accuracy': accuracy_score(y_test, y_pred),
+                    'classification_report': classification_report(y_test, y_pred, output_dict=True),
+                    'confusion_matrix': confusion_matrix(y_test, y_pred).tolist(),
+                    'y_pred': y_pred
+                })
+            elif problem_type == 'regression':
+                results.update({
+                    'test_mse': mean_squared_error(y_test, y_pred),
+                    'test_rmse': np.sqrt(mean_squared_error(y_test, y_pred)),
+                    'test_mae': mean_absolute_error(y_test, y_pred),
+                    'test_r2': r2_score(y_test, y_pred),
+                    'y_pred': y_pred
+                })
+            else:
+                results['test_predictions'] = y_pred
+
+        return results
+
+    @staticmethod
+    def create_class_distribution_plot(y_original):
+        """
+        Crear un gráfico de distribución de clases
+        
+        Args:
+            y_original (pd.Series): Variable objetivo original
+        
+        Returns:
+            plotly.graph_objs._figure.Figure: Gráfico de distribución de clases
+        """
+        class_dist = pd.DataFrame({
+            'Clase': y_original.value_counts().index,
+            'Cantidad': y_original.value_counts().values
+        })
+        
+        fig = px.bar(
+            class_dist,
+            x='Clase',
+            y='Cantidad',
+            title='Distribución de clases'
+        )
+        
+        return fig
+
+    @staticmethod
+    def process_classification_data(y, random_state):
+        """
+        Procesar datos de clasificación
+        
+        Args:
+            y (pd.Series): Variable objetivo
+            random_state (int): Semilla aleatoria
+        
+        Returns:
+            tuple: Variable objetivo procesada y codificador de etiquetas
+        """
+        # Codificación de etiquetas
+        le = LabelEncoder()
+        y_encoded = pd.Series(le.fit_transform(y))
+        
+        return y_encoded, le
+
+    @staticmethod
+    def save_model(model, filename):
+        """
+        Guardar modelo entrenado en un archivo
+        
+        Args:
+            model: Modelo entrenado
+            filename (str): Nombre del archivo
+        """
+        if isinstance(model, h2o.estimators.H2OEstimator):
+            # Usar método nativo de H2O para guardar modelos
+            h2o.save_model(model=model, path=os.path.dirname(filename), force=True)
+        else:
+            with open(filename, 'wb') as f:
+                pickle.dump(model, f)
+
+    @staticmethod
+    def load_model(filename):
+        """
+        Cargar modelo desde un archivo
+        
+        Args:
+            filename (str): Nombre del archivo
+        
+        Returns:
+            Modelo cargado
+        """
+        if filename.endswith('.zip'):
+            # Asumir que es un modelo H2O
+            return h2o.load_model(filename)
+        else:
+            with open(filename, 'rb') as f:
+                return pickle.load(f)
+
+    @staticmethod
+    def get_model_performance_metrics(y_true, y_pred, problem_type):
+        """
+        Obtener métricas de rendimiento del modelo
+        
+        Args:
+            y_true (pd.Series): Etiquetas verdaderas
+            y_pred (pd.Series): Etiquetas predichas
+            problem_type (str): Tipo de problema
+        
+        Returns:
+            dict: Métricas de rendimiento
+        """
+        if problem_type == 'classification':
+            return {
+                'accuracy': accuracy_score(y_true, y_pred),
+                'classification_report': classification_report(y_true, y_pred, output_dict=True)
+            }
+        else:  # Regresión
+            return {
+                'mse': mean_squared_error(y_true, y_pred),
+                'r2_score': r2_score(y_true, y_pred)
+            }
+
+    @staticmethod
+    def split_data(X, y, test_size=0.2, random_state=42):
+        """
+        Dividir datos en conjuntos de entrenamiento y prueba
+        
+        Args:
+            X (pd.DataFrame): Features
+            y (pd.Series): Variable objetivo
+            test_size (float): Proporción de datos de prueba
+            random_state (int): Semilla aleatoria
+        
+        Returns:
+            tuple: X_train, X_test, y_train, y_test
+        """
+        return train_test_split(X, y, test_size=test_size, random_state=random_state)
+
+    @staticmethod
+    def prepare_data_for_ml(df, target_column, problem_type='classification', test_size=0.2, random_state=42):
+        """
+        Preparar datos para machine learning
+        
+        Args:
+            df (pd.DataFrame): DataFrame de datos
+            target_column (str): Columna objetivo
+            problem_type (str): Tipo de problema
+            test_size (float): Proporción de datos de prueba
+            random_state (int): Semilla aleatoria
+        
+        Returns:
+            dict: Diccionario con datos preparados
+        """
+        # Separar features y target
+        X = df.drop(columns=[target_column])
+        y = df[target_column]
+
+        # Preprocesar datos según el tipo de problema
+        if problem_type == 'classification':
+            y, label_encoder = ModelTrainer.process_classification_data(y, random_state)
+        else:
+            label_encoder = None
+
+        # Dividir datos
+        X_train, X_test, y_train, y_test = ModelTrainer.split_data(X, y, test_size, random_state)
+
+        return {
+            'X_train': X_train,
+            'X_test': X_test,
+            'y_train': y_train,
+            'y_test': y_test,
+            'label_encoder': label_encoder,
+            'features': list(X.columns),
+            'problem_type': problem_type
+        }
+
+    @staticmethod
+    def generate_model_comparison_report(trained_models, problem_type):
+        """
+        Generar informe comparativo de modelos
+        
+        Args:
+            trained_models (dict): Modelos entrenados
+            problem_type (str): Tipo de problema
+        
+        Returns:
+            pd.DataFrame: Informe comparativo de modelos
+        """
+        comparison_data = []
+
+        for model_name, model_info in trained_models.items():
+            model_metrics = ModelTrainer.get_model_performance_metrics(
+                model_info['y_test'], 
+                model_info['y_pred'], 
+                problem_type
+            )
+
+            model_entry = {
+                'Modelo': model_name,
+                'Tiempo de Entrenamiento': model_info.get('training_time', 0),
+            }
+
+            # Agregar métricas según el tipo de problema
+            if problem_type == 'classification':
+                model_entry.update({
+                    'Precisión': model_metrics['accuracy'],
+                    'Precisión (Macro)': model_metrics['classification_report']['macro avg']['precision'],
+                    'Recall (Macro)': model_metrics['classification_report']['macro avg']['recall'],
+                    'F1-Score (Macro)': model_metrics['classification_report']['macro avg']['f1-score']
+                })
+            else:
+                model_entry.update({
+                    'MSE': model_metrics['mse'],
+                    'R2 Score': model_metrics['r2_score']
+                })
+
+            comparison_data.append(model_entry)
+
+        return pd.DataFrame(comparison_data)
+
+    @staticmethod
+    def plot_model_comparison(comparison_df, problem_type):
+        """
+        Crear gráfico comparativo de modelos
+        
+        Args:
+            comparison_df (pd.DataFrame): DataFrame de comparación de modelos
+            problem_type (str): Tipo de problema
+        
+        Returns:
+            plotly.graph_objs._figure.Figure: Gráfico comparativo
+        """
+        metric_column = 'Precisión' if problem_type == 'classification' else 'R2 Score'
+        
+        fig = px.bar(
+            comparison_df, 
+            x='Modelo', 
+            y=metric_column,
+            title=f'Comparación de Modelos - {metric_column}'
+        )
+        
+        return fig
+
+# Funciones sueltas para importación directa
+def get_model_options(problem_type):
+    return ModelTrainer.get_model_options(problem_type)
+
+def train_model_pipeline(*args, **kwargs):
+    return ModelTrainer.train_model_pipeline(*args, **kwargs)
+
+def process_classification_data(y, random_state=42):
+    return ModelTrainer.process_classification_data(y, random_state)
+
+def create_class_distribution_plot(y):
+    return ModelTrainer.create_class_distribution_plot(y)

utils/shap_explainer.py

@@ -0,0 +1,469 @@
+# utils/shap_explainer.py
+import streamlit as st
+import pandas as pd
+import numpy as np
+import shap
+import plotly.express as px
+import plotly.graph_objects as go
+from typing import Dict, Any, Union, Optional
+from sklearn.pipeline import Pipeline
+import h2o
+import streamlit as st
+import pandas as pd
+import numpy as np
+import shap
+import plotly.express as px
+import plotly.graph_objects as go
+from typing import Dict, Any, Optional, Union
+from sklearn.pipeline import Pipeline
+
+class SHAPExplainer:
+    """
+    Clase para realizar explicaciones de modelos usando SHAP (SHapley Additive exPlanations)
+    """
+    def __init__(self, model, X: pd.DataFrame, problem_type: str = 'classification', explanation_method: str = 'auto'):
+        """
+        Inicializar el explicador SHAP
+
+        Args:
+            model: Modelo de machine learning entrenado
+            X (pd.DataFrame): Datos de entrada para el modelo
+            problem_type (str): Tipo de problema ('classification' o 'regression')
+            explanation_method (str): Método de explicación ('auto', 'tree', 'linear', 'kernel')
+        """
+        self.model = model
+        self.X = X
+        self.problem_type = problem_type
+        self.explanation_method = explanation_method
+        self.explainer = self._create_explainer()
+        self.X_sample = None  # Inicializar X_sample
+
+    def _create_explainer(self):
+        """
+        Crear el explicador SHAP apropiado según el tipo de modelo y método seleccionado,
+        manejando correctamente los Pipelines y modelos de H2O.
+
+        Returns:
+            Explainer de SHAP
+        """
+        try:
+            # Si el modelo es un Pipeline, extraer el estimador final
+            if isinstance(self.model, Pipeline):
+                estimator = self.model.steps[-1][1]
+            else:
+                estimator = self.model
+
+            # Verificar si el modelo es de H2O
+            if isinstance(estimator, h2o.estimators.H2OEstimator):
+                # Usar KernelExplainer para modelos de H2O
+                # Obtener función de predicción compatible con SHAP
+                def predict_function(x):
+                    h2o_frame = h2o.H2OFrame(x)
+                    preds = estimator.predict(h2o_frame)
+                    return preds.as_data_frame()['predict'].values
+
+                return shap.KernelExplainer(predict_function, shap.sample(self.X, 100))
+            
+            # Crear el explicador usando el método seleccionado
+            if self.explanation_method.lower() == 'tree':
+                return shap.TreeExplainer(estimator)
+            elif self.explanation_method.lower() == 'linear':
+                return shap.LinearExplainer(estimator, self.X, feature_dependence="independent")
+            elif self.explanation_method.lower() == 'kernel':
+                return shap.KernelExplainer(estimator.predict, shap.sample(self.X, 100))
+            else:
+                # 'auto' o cualquier otro valor: usar shap.Explainer que selecciona automáticamente
+                return shap.Explainer(estimator, self.X)
+
+        except Exception as e:
+            st.error(f"Error al crear explicador SHAP: {str(e)}")
+            return None
+
+    def compute_shap_values(self, X_sample: Optional[pd.DataFrame] = None, max_samples: int = 100):
+        """
+        Calcular valores SHAP
+
+        Args:
+            X_sample (pd.DataFrame, opcional): Muestra de datos para calcular SHAP
+            max_samples (int): Número máximo de muestras a procesar
+
+        Returns:
+            Valores SHAP
+        """
+        try:
+            # Usar muestra si no se proporciona
+            if X_sample is None:
+                X_sample = self.X.sample(n=min(max_samples, len(self.X)), random_state=42)
+
+            # Almacenar el subconjunto de datos utilizado
+            self.X_sample = X_sample
+
+            # Asegurarse de que X_sample es 2D
+            if X_sample.ndim != 2:
+                raise ValueError(f"Debe pasar una entrada 2D a SHAP. La forma actual es {X_sample.shape}")
+
+            # Calcular valores SHAP usando el explicador
+            shap_values = self.explainer.shap_values(X_sample)
+
+            # Para clasificación multiclase, SHAP devuelve una lista de arrays
+            if isinstance(shap_values, list):
+                # Promediar las contribuciones de todas las clases
+                shap_values = np.mean(np.abs(shap_values), axis=0)
+
+            else:
+                shap_values = np.abs(shap_values)
+
+            return shap_values
+
+        except Exception as e:
+            st.error(f"Error al calcular valores SHAP: {str(e)}")
+            return None
+
+    def plot_summary(self, shap_values, title: str = "SHAP Summary Plot"):
+        """
+        Generar gráfico de resumen de valores SHAP
+
+        Args:
+            shap_values: Valores SHAP calculados
+            title (str): Título del gráfico
+
+        Returns:
+            Figura de Plotly
+        """
+        try:
+            feature_names = self.X.columns.tolist()
+
+            # Calcular importancia de características
+            feature_importance = np.mean(shap_values, axis=0)
+            importance_df = pd.DataFrame({
+                'feature': feature_names,
+                'importance': feature_importance
+            }).sort_values('importance', ascending=False)
+
+            # Gráfico de barras de importancia
+            fig = px.bar(
+                importance_df, 
+                x='importance', 
+                y='feature', 
+                orientation='h',
+                title=title,
+                labels={'importance': 'Importancia SHAP', 'feature': 'Características'}
+            )
+
+            return fig
+
+        except Exception as e:
+            st.error(f"Error al generar gráfico de resumen: {str(e)}")
+            return None
+
+    def plot_dependence(self, shap_values, feature_name: str):
+        """
+        Generar gráfico de dependencia para una característica
+
+        Args:
+            shap_values: Valores SHAP calculados
+            feature_name (str): Nombre de la característica
+
+        Returns:
+            Figura de Plotly
+        """
+        try:
+            feature_idx = self.X.columns.get_loc(feature_name)
+
+            # Preparar datos usando el mismo subconjunto de datos utilizado para SHAP
+            if self.X_sample is not None:
+                x = self.X_sample.iloc[:, feature_idx]
+            else:
+                x = self.X.iloc[:, feature_idx]
+
+            y = shap_values[:, feature_idx]
+
+            # Verificar que las longitudes coincidan
+            if len(x) != len(y):
+                raise ValueError(f"Longitud de 'x' ({len(x)}) y 'y' ({len(y)}) no coinciden.")
+
+            # Crear scatter plot
+            fig = px.scatter(
+                x=x, 
+                y=y, 
+                title=f'SHAP Dependence Plot - {feature_name}',
+                labels={'x': feature_name, 'y': 'SHAP Value'}
+            )
+
+            return fig
+
+        except Exception as e:
+            st.error(f"Error al generar gráfico de dependencia: {str(e)}")
+            return None
+
+    def generate_feature_importance_report(self, shap_values) -> Dict[str, Any]:
+        """
+        Generar un informe detallado de importancia de características
+
+        Args:
+            shap_values: Valores SHAP calculados
+
+        Returns:
+            Diccionario con información de importancia de características
+        """
+        try:
+            # Calcular importancia
+            feature_importance = np.mean(shap_values, axis=0)
+
+            # Crear DataFrame de importancia
+            importance_df = pd.DataFrame({
+                'feature': self.X.columns,
+                'importance': feature_importance
+            }).sort_values('importance', ascending=False)
+
+            # Generar informe
+            report = {
+                'top_features': importance_df.head(5).to_dict('records'),
+                'bottom_features': importance_df.tail(5).to_dict('records'),
+                'total_features': len(importance_df),
+                'max_importance': importance_df['importance'].max(),
+                'min_importance': importance_df['importance'].min()
+            }
+
+            return report
+
+        except Exception as e:
+            st.error(f"Error al generar informe de importancia: {str(e)}")
+            return {}
+
+def create_shap_analysis_dashboard(model, X: pd.DataFrame, problem_type: str = 'classification'):
+    """
+    Crear un dashboard de análisis SHAP en Streamlit
+
+    Args:
+        model: Modelo de machine learning
+        X (pd.DataFrame): Datos de entrada
+        problem_type (str): Tipo de problema
+    """
+    st.title("🔍 Análisis de Explicabilidad SHAP")
+
+    # Inicializar los valores SHAP en session_state si no existen
+    if 'shap_explainer' not in st.session_state:
+        # Parámetros por defecto
+        explanation_method = 'auto'
+        max_samples = 100
+
+        # Crear y almacenar el explicador SHAP
+        st.session_state.shap_explainer = SHAPExplainer(
+            model=model,
+            X=X,
+            problem_type=problem_type,
+            explanation_method=explanation_method
+        )
+
+        # Calcular y almacenar los valores SHAP
+        st.session_state.shap_values = st.session_state.shap_explainer.compute_shap_values(
+            max_samples=max_samples
+        )
+
+    shap_explainer = st.session_state.shap_explainer
+    shap_values = st.session_state.shap_values
+
+    if shap_values is None:
+        st.error("No se pudieron calcular los valores SHAP")
+        return
+
+    # Pestañas para diferentes visualizaciones
+    tab1, tab2, tab3, tab4 = st.tabs([
+        "Resumen de Importancia", 
+        "Dependencia de Características", 
+        "Informe Detallado", 
+        "Configuración Avanzada"
+    ])
+
+    with tab1:
+        st.header("Resumen de Importancia de Características")
+
+        # Gráfico de resumen
+        summary_fig = shap_explainer.plot_summary(shap_values)
+        if summary_fig:
+            st.plotly_chart(summary_fig, use_container_width=True)
+
+        # Selector de características para análisis detallado
+        selected_feature = st.selectbox(
+            "Seleccionar característica para análisis detallado",
+            X.columns.tolist()
+        )
+
+        # Gráfico de dependencia para la característica seleccionada
+        dependence_fig = shap_explainer.plot_dependence(shap_values, selected_feature)
+        if dependence_fig:
+            st.plotly_chart(dependence_fig, use_container_width=True)
+
+    with tab2:
+        st.header("Análisis de Dependencia de Características")
+
+        # Matriz de correlación de valores SHAP
+        shap_correlation = pd.DataFrame(shap_values).corr()
+
+        # Heatmap de correlación de valores SHAP
+        fig_corr = px.imshow(
+            shap_correlation, 
+            title="Correlación entre Valores SHAP de Características",
+            labels=dict(x="Características", y="Características", color="Correlación")
+        )
+        st.plotly_chart(fig_corr, use_container_width=True)
+
+    with tab3:
+        st.header("Informe Detallado de Importancia")
+
+        # Generar informe de importancia de características
+        importance_report = shap_explainer.generate_feature_importance_report(shap_values)
+
+        # Mostrar características más importantes
+        st.subheader("Top 5 Características Más Importantes")
+        top_features_df = pd.DataFrame(importance_report.get('top_features', []))
+        st.dataframe(top_features_df)
+
+        # Visualización de características más importantes
+        fig_top_features = px.bar(
+            top_features_df, 
+            x='importance', 
+            y='feature',
+            orientation='h',
+            title="Top 5 Características por Importancia SHAP"
+        )
+        st.plotly_chart(fig_top_features, use_container_width=True)
+
+        # Métricas de resumen
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("Total de Características", importance_report.get('total_features', 'N/A'))
+        with col2:
+            st.metric("Máxima Importancia", f"{importance_report.get('max_importance', 'N/A'):.4f}")
+        with col3:
+            st.metric("Mínima Importancia", f"{importance_report.get('min_importance', 'N/A'):.4f}")
+
+    with tab4:
+        st.header("Configuración Avanzada")
+
+        # Controles de configuración
+        st.subheader("Parámetros de Explicación")
+
+        # Selector de método de explicación
+        explanation_method = st.selectbox(
+            "Método de Explicación",
+            ["auto", "tree", "linear", "kernel"]
+        )
+
+        # Número de muestras para cálculo
+        num_samples = st.slider(
+            "Número de Muestras para Análisis",
+            min_value=10,
+            max_value=min(1000, len(X)),
+            value=min(100, len(X))
+        )
+
+        # Botón para recalcular con nuevos parámetros
+        if st.button("Recalcular SHAP"):
+            with st.spinner("Recalculando valores SHAP..."):
+                try:
+                    # Crear y actualizar el explicador SHAP con nuevos parámetros
+                    shap_explainer = SHAPExplainer(
+                        model=model,
+                        X=X,
+                        problem_type=problem_type,
+                        explanation_method=explanation_method
+                    )
+                    st.session_state.shap_explainer = shap_explainer
+
+                    # Calcular y actualizar los valores SHAP
+                    shap_values = shap_explainer.compute_shap_values(
+                        max_samples=num_samples
+                    )
+                    st.session_state.shap_values = shap_values
+
+                    st.success("Valores SHAP recalculados correctamente.")
+
+                except Exception as e:
+                    st.error(f"Error al recalcular SHAP: {str(e)}")
+
+def validate_shap_compatibility(model):
+    """
+    Validar si un modelo es compatible con SHAP
+    
+    Args:
+        model: Modelo de machine learning
+    
+    Returns:
+        bool: True si es compatible, False en caso contrario
+    """
+    compatible_types = [
+        'RandomForestClassifier',
+        'RandomForestRegressor',
+        'GradientBoostingClassifier',
+        'GradientBoostingRegressor',
+        'XGBClassifier',
+        'XGBRegressor',
+        'DecisionTreeClassifier',
+        'DecisionTreeRegressor',
+        'LogisticRegression',
+        'LinearRegression'
+    ]
+    
+    return any(
+        comp_type in str(type(model).__name__) 
+        for comp_type in compatible_types
+    )
+
+def generate_shap_documentation():
+    """
+    Generar documentación sobre el uso de SHAP
+    
+    Returns:
+        str: Documentación en formato markdown
+    """
+    documentation = """
+    ## 🔍 Explicabilidad de Modelos con SHAP
+
+    ### ¿Qué es SHAP?
+    SHAP (SHapley Additive exPlanations) es una metodología para explicar las predicciones 
+    de modelos de machine learning basada en la teoría de juegos.
+
+    ### Características Principales
+    - Interpretación global y local de modelos
+    - Calcula la contribución de cada característica a la predicción
+    - Funciona con diferentes tipos de modelos
+
+    ### Tipos de Visualizaciones
+    1. **Summary Plot**: Importancia general de características
+    2. **Dependence Plot**: Relación entre características y predicciones
+    3. **Force Plot**: Contribución individual de características
+
+    ### Limitaciones
+    - Computacionalmente intensivo para grandes datasets
+    - Puede ser lento con modelos complejos
+    - Requiere comprensión estadística para interpretación precisa
+
+    ### Mejores Prácticas
+    - Usar como complemento, no como única fuente de verdad
+    - Combinar con otras técnicas de explicabilidad
+    - Interpretar en contexto del problema de negocio
+    """
+    return documentation
+
+# Punto de entrada principal para pruebas
+def main():
+    import streamlit as st
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.datasets import load_iris
+    
+    # Cargar datos de ejemplo
+    iris = load_iris()
+    X = pd.DataFrame(iris.data, columns=iris.feature_names)
+    y = iris.target
+    
+    # Entrenar modelo de ejemplo
+    model = RandomForestClassifier(n_estimators=100, random_state=42)
+    model.fit(X, y)
+    
+    # Crear dashboard de análisis SHAP
+    create_shap_analysis_dashboard(model, X)
+
+if __name__ == "__main__":
+    main()