Update src/app.py

src/app.py

@@ -7,11 +7,12 @@ from sklearn.preprocessing import PolynomialFeatures
 from sklearn.neighbors import KNeighborsRegressor
 from sklearn.metrics import r2_score, mean_squared_error
 import numpy as np
+import requests
 
 # Configuración inicial
 st.set_page_config(page_title="📊 Dashboard Avanzado", layout="wide")
 st.title("🧠 Dashboard Dinámico con Análisis Avanzado")
-st.markdown("Carga un CSV y explora visualizaciones + modelos de ML automáticamente.")
+st.markdown("Carga un CSV y explora visualizaciones + modelos de ML + IA generativa.")
 
 # Subida de archivo
 uploaded_file = st.file_uploader("📁 Cargar archivo CSV", type=["csv"])
@@ -19,7 +20,12 @@ if uploaded_file:
     df = pd.read_csv(uploaded_file)
     
     # Tabs para organización
-    tabs = st.tabs(["🔍 Datos", "📊 Visualizaciones", "🤖 Machine Learning"])
+    tabs = st.tabs([
+        "🔍 Datos", 
+        "📊 Visualizaciones", 
+        "🤖 Machine Learning",
+        "🧠 Análisis con IA Generativa"
+    ])
     
     # Pestaña 1: Datos
     with tabs[0]:
@@ -64,7 +70,7 @@ if uploaded_file:
                 try:
                     fig = None
                     if plot_type == "Scatter":
-                        fig = px.scatter(df, x=x_col, y=y_col, trendline="ols")
+                        fig = px.scatter(df, x=x_col, y=y_col)  # Sin trendline para evitar dependencia statsmodels
                     elif plot_type == "Line":
                         fig = px.line(df, x=x_col, y=y_col)
                     elif plot_type == "Bar":
@@ -92,41 +98,96 @@ if uploaded_file:
         )
         
         # Selección de variables
-        target = st.selectbox("Variable objetivo (Y)", numeric_cols)
-        features = st.multiselect("Variables independientes (X)", numeric_cols, default=numeric_cols[:1])
-        
-        if st.button("Entrenar Modelo"):
-            if len(features) == 0 or target is None:
-                st.error("Selecciona al menos una variable independiente y una dependiente.")
+        numeric_cols = df.select_dtypes(include=np.number).columns.tolist()
+        if len(numeric_cols) < 2:
+            st.warning("Necesitas al menos dos columnas numéricas para entrenar un modelo.")
+        else:
+            target = st.selectbox("Variable objetivo (Y)", numeric_cols)
+            features = st.multiselect("Variables independientes (X)", numeric_cols, default=numeric_cols[:1])
+            
+            if st.button("Entrenar Modelo"):
+                if len(features) == 0 or target is None:
+                    st.error("Selecciona al menos una variable independiente y una dependiente.")
+                else:
+                    X = df[features]
+                    y = df[target]
+                    
+                    # Entrenamiento según modelo
+                    model = None
+                    if model_type == "Linear Regression":
+                        model = LinearRegression()
+                    elif model_type == "Polynomial Regression":
+                        poly = PolynomialFeatures(degree=2)
+                        X = poly.fit_transform(X)
+                        model = LinearRegression()
+                    elif model_type == "K-Nearest Neighbors":
+                        model = KNeighborsRegressor(n_neighbors=5)
+                    
+                    model.fit(X, y)
+                    y_pred = model.predict(X)
+                    
+                    # Métricas
+                    r2 = r2_score(y, y_pred)
+                    mse = mean_squared_error(y, y_pred)
+                    
+                    # Resultados
+                    st.write(f"**R² Score:** {r2:.2f}")
+                    st.write(f"**Mean Squared Error:** {mse:.2f}")
+                    
+                    # Gráfico de predicción vs real
+                    fig = go.Figure()
+                    fig.add_trace(go.Scatter(x=y, y=y_pred, mode='markers', name='Predicción'))
+                    fig.add_trace(go.Scatter(x=[y.min(), y.max()], y=[y.min(), y.max()], mode='lines', name='Ideal'))
+                    fig.update_layout(title="Predicción vs Valores Reales", xaxis_title="Real", yaxis_title="Predicho")
+                    st.plotly_chart(fig)
+    
+    # Pestaña 4: IA Generativa
+    with tabs[3]:
+        st.subheader("💬 Usar IA Generativa (Gemini API)")
+        st.markdown("Introduce tu clave de API de Gemini y haz preguntas sobre los datos.")
+
+        # Campo para la API Key
+        gemini_api_key = st.text_input("Gemini API Key", type="password")
+
+        # Campo para la pregunta
+        user_query = st.text_area(
+            "Haz una pregunta sobre los datos",
+            "¿Cuál es el promedio de la columna X? ¿Hay alguna correlación entre X e Y?"
+        )
+
+        if st.button("Enviar a Gemini"):
+            if not gemini_api_key:
+                st.error("Por favor, introduce una API Key válida.")
             else:
-                X = df[features]
-                y = df[target]
-                
-                # Entrenamiento según modelo
-                model = None
-                if model_type == "Linear Regression":
-                    model = LinearRegression()
-                elif model_type == "Polynomial Regression":
-                    poly = PolynomialFeatures(degree=2)
-                    X = poly.fit_transform(X)
-                    model = LinearRegression()
-                elif model_type == "K-Nearest Neighbors":
-                    model = KNeighborsRegressor(n_neighbors=5)
-                
-                model.fit(X, y)
-                y_pred = model.predict(X)
-                
-                # Métricas
-                r2 = r2_score(y, y_pred)
-                mse = mean_squared_error(y, y_pred)
-                
-                # Resultados
-                st.write(f"**R² Score:** {r2:.2f}")
-                st.write(f"**Mean Squared Error:** {mse:.2f}")
+                try:
+                    # Datos del dataset como contexto
+                    context = f"""
+                    Estos son los primeros 5 registros del dataset cargado:
+                    {df.head().to_string()}
+                    
+                    Pregunta del usuario: {user_query}
+                    """
+                    
+                    # Llamada a la API de Gemini
+                    url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key=" + gemini_api_key
+                    
+                    payload = {
+                        "contents": [{"parts": [{"text": context}]}]
+                    }
+                    
+                    headers = {
+                        "Content-Type": "application/json"
+                    }
+                    
+                    response = requests.post(url, json=payload, headers=headers)
+                    
+                    if response.status_code == 200:
+                        result = response.json()
+                        ai_response = result["candidates"][0]["content"]["parts"][0]["text"]
+                        st.markdown("### 🤖 Respuesta de Gemini:") 
+                        st.markdown(ai_response)
+                    else:
+                        st.error(f"Error en la API: {response.status_code} - {response.text}")
                 
-                # Gráfico de predicción vs real
-                fig = go.Figure()
-                fig.add_trace(go.Scatter(x=y, y=y_pred, mode='markers', name='Predicción'))
-                fig.add_trace(go.Scatter(x=[y.min(), y.max()], y=[y.min(), y.max()], mode='lines', name='Ideal'))
-                fig.update_layout(title="Predicción vs Valores Reales", xaxis_title="Real", yaxis_title="Predicho")
-                st.plotly_chart(fig)
+                except Exception as e:
+                    st.error(f"Error al conectar con Gemini: {e}")