Update app.py

app.py

@@ -1,439 +1,439 @@
-import streamlit as st
-import pandas as pd
-import numpy as np
-import plotly.graph_objects as go
-from scipy.optimize import minimize, differential_evolution
-from sklearn.preprocessing import PolynomialFeatures
-from sklearn.linear_model import LinearRegression
-from sklearn.metrics import mean_squared_error, r2_score
-import matplotlib.pyplot as plt
-import seaborn as sns
-import io
-# Configuración inicial
-# Configuración de la aplicación
-st.set_page_config(page_title="Optimización Avanzada", page_icon="📊",layout="wide")
-# Display the image above the title
-st.image('cannabis.jpg')
-st.title("Optimización Avanzada con Diseño Experimental Box-Behnken")
-st.write("Aplicación con regresión cuadrática y estrategias de optimización mejoradas.")
-
-# Crear las pestañas
-tabs = st.selectbox("Selecciona una opción", ["Fundamento Teórico", "Aplicación Interactiva"])
-
-if tabs == "Fundamento Teórico":
-    st.header("Fundamento Teórico")
-    
-    # Imagen del proceso
-    st.subheader("Proceso de Extracción de CBD")
-    st.image("CBD extraction process.png", caption="Proceso de Extracción de CBD con CO2 Supercrítico", use_column_width=True)
-    st.write("""
-    El proceso de extracción de CBD utiliza tecnología de CO2 supercrítico debido a su eficiencia y capacidad para producir extractos puros. Este método incluye etapas clave como molienda, extracción, separación y refinamiento, garantizando un producto de alta calidad para aplicaciones medicinales y comerciales.
-    """)
-
-    # Diseño Experimental Box-Behnken
-    st.subheader("Diseño Experimental Box-Behnken")
-    st.write("""
-    El diseño experimental **Box-Behnken** se utiliza para modelar y optimizar procesos complejos. En este caso, se aplica para maximizar el rendimiento de CBD considerando variables clave como **Temperatura**, **Presión**, **Flujo de CO2** y **Tiempo**.
-    Este enfoque reduce significativamente la cantidad de experimentos necesarios, permitiendo explorar interacciones no lineales de manera eficiente.
-    """)
-
-    # Proceso de Producción de CBD
-    st.subheader("Proceso de Producción de CBD")
-    st.write("""
-    Según el documento *Optimization of Supercritical Carbon Dioxide Fluid Extraction of Medicinal Cannabis from Quebec*, el proceso de extracción con CO2 supercrítico es preferido por su alta selectividad y pureza. Las principales etapas incluyen:
-    1. **Preparación de la materia prima**: Molienda y acondicionamiento.
-    2. **Extracción supercrítica**:
-        - El CO2 actúa como solvente bajo condiciones controladas de presión y temperatura.
-        - Variables clave: presión (150-320 bar), temperatura (40-70°C), flujo de CO2 (5-15 g/min), tiempo (2-4 horas).
-    3. **Separación y recolección**: El CO2 se despresuriza para liberar los cannabinoides extraídos.
-    4. **Refinamiento posterior**: Remoción de ceras y otros compuestos no deseados.
-    """)
-
-    # Caso de Negocio
-    st.subheader("Caso de Negocio: Optimización del Rendimiento")
-    st.write("""
-    Optimizar el rendimiento del proceso de extracción permite:
-    - Maximizar la cantidad de CBD extraído por lote.
-    - Reducir costos operativos (energía, solventes, tiempo).
-    - Mejorar la calidad del producto final.
-    
-    Este enfoque es crucial en la industria del cannabis medicinal, donde la eficiencia del proceso impacta directamente en la rentabilidad y sostenibilidad del negocio.
-    """)
-
-    # Método Basado en CRISP-DM
-    st.subheader("Metodología Basada en CRISP-DM")
-    st.write("""
-    La metodología **CRISP-DM** estructura el desarrollo del modelo en seis etapas:
-    1. **Comprensión del Negocio**: Definir objetivos y restricciones del proceso.
-    2. **Comprensión de los Datos**: Analizar datos experimentales y evaluar su calidad.
-    3. **Preparación de los Datos**: Limpiar y transformar datos para el modelado.
-    4. **Modelado**: Ajustar un modelo de regresión cuadrática para capturar relaciones no lineales.
-    5. **Evaluación**: Validar el modelo y analizar su desempeño.
-    6. **Despliegue**: Implementar el modelo en una aplicación interactiva para optimización en tiempo real.
-    """)
-
-    # Optimización
-    st.subheader("Optimización")
-    st.write("""
-    Se emplean técnicas avanzadas para maximizar el rendimiento:
-    - **L-BFGS-B**: Método de optimización local.
-    - **Evolución Diferencial**: Optimización global para evitar óptimos locales.
-    - **Múltiples inicios aleatorios**: Combina estrategias locales y globales para robustez.
-    """)
-
-    # Referencias
-    st.subheader("Referencias")
-    st.write("""
-    - [Optimization of Supercritical Carbon Dioxide Fluid Extraction of Medicinal Cannabis from Quebec](https://www.mdpi.com/2227-9717/11/7/1953).
-    - Herrero, M., Cifuentes, A., & Ibañez, E. (2006). Supercritical fluid extraction: Recent advances and applications. *Journal of Chromatography A*, 1131(1), 1–24.
-    - Turner, C., Mathiasson, L., & Lewis, G. (2001). Supercritical fluid extraction and chromatography. *Journal of Biochemical Analysis*, 121(3), 35–58.
-    """)
-
-elif tabs == "Aplicación Interactiva":
-    st.header("Aplicación Interactiva")
-    st.write("A continuación, puedes cargar tus datos, realizar predicciones y optimizar el rendimiento del proceso de extracción de cannabinoides.")
-
-    # Opciones de selección de datos de ejemplo
-    st.subheader("Datos de Ejemplo")
-    usar_datos_exp = st.checkbox("Usar datos de ejemplo: datos_exp.csv")
-    usar_datos_process = st.checkbox("Usar datos de ejemplo: datos_process.csv")
-
-    # Inicializar variable de datos
-    data = None
-
-    # Verificar qué checkbox está seleccionado y cargar el archivo correspondiente
-    if usar_datos_exp and not usar_datos_process:
-        data = pd.read_csv("data_exp.csv")
-        st.success("Datos de ejemplo (datos_exp.csv) cargados exitosamente.")
-        st.dataframe(data, use_container_width=True)  # Ajustar al ancho de la app
-    elif usar_datos_process and not usar_datos_exp:
-        data = pd.read_csv("data_process.csv")
-        st.success("Datos de ejemplo (datos_process.csv) cargados exitosamente.")
-        st.dataframe(data, use_container_width=True)  # Ajustar al ancho de la app
-    elif usar_datos_exp and usar_datos_process:
-        st.error("Por favor, selecciona solo un conjunto de datos de ejemplo a la vez.")
-    
-    # Opción para cargar datos personalizados
-    st.subheader("Carga tus Datos")
-    uploaded_file = st.file_uploader("Carga un archivo CSV con los datos experimentales:", type="csv")
-
-    if uploaded_file is not None:
-        # Leer datos cargados
-        data = pd.read_csv(uploaded_file)
-        st.success("Datos cargados exitosamente desde el archivo proporcionado.")
-        st.dataframe(data, use_container_width=True)  # Ajustar al ancho de la app
-
-    # Validación para asegurarse de que se cargaron datos
-    if data is None:
-        st.warning("No se han cargado datos. Por favor, selecciona un archivo o usa datos de ejemplo.")
-    else:
-        st.write("### Datos listos para su análisis.")
-
-        # Definir el orden fijo de variables
-        variable_columns = ['Temperatura', 'Presión', 'Flujo_CO2', 'Tiempo']
-
-        # Extraer variables independientes y dependiente en el orden correcto
-        X = data[variable_columns]
-        y = data['Rendimiento']
-
-        # Generar términos cuadráticos (regresión polinómica de segundo grado)
-        poly = PolynomialFeatures(degree=2, include_bias=False)
-        X_poly = poly.fit_transform(X)
-        columnas_poly = poly.get_feature_names_out(X.columns)
-
-        # Ajustar modelo cuadrático
-        modelo = LinearRegression()
-        modelo.fit(X_poly, y)
-
-        # Predicciones del modelo
-        y_pred = modelo.predict(X_poly)
-
-        # Evaluación del modelo
-        st.subheader("Evaluación del Modelo Cuadrático")
-        st.write(f"**Error Cuadrático Medio (MSE):** {mean_squared_error(y, y_pred):.4f}")
-        st.write(f"**R² (Coeficiente de Determinación):** {r2_score(y, y_pred):.4f}")
-
-        # Resumen del modelo: coeficientes
-
-        # Visualización paralela usando columnas
-        col1, col2 = st.columns(2)
-
-        # En la columna 1, mostrar el DataFrame con términos y coeficientes, adaptado al ancho de la columna
-        with col1:
-            st.markdown("#### Términos y Coeficientes del Modelo")
-
-            # Crear un DataFrame con los coeficientes
-            coeficientes = pd.DataFrame({
-                'Término': columnas_poly, 
-                'Coeficiente': modelo.coef_
-            })
-            
-            coeficientes = coeficientes.sort_values(by='Coeficiente', ascending=False)
-            
-            # Función para aplicar colores a los coeficientes
-            def color_coef(val):
-                color = 'red' if val > 0 else 'blue'  # Los coeficientes positivos serán rojos, negativos azules
-                return f'background-color: {color}; color: white;'
-
-            # Aplicar estilo a la columna 'Coeficiente' para colorear los valores
-            styled_coef = coeficientes.style.applymap(color_coef, subset=['Coeficiente'])
-
-            # Mostrar el DataFrame estilizado y ajustado al ancho de la columna
-            st.dataframe(styled_coef, use_container_width=True)
-
-        # En la columna 2, mostrar el gráfico de importancia de las variables, adaptado al ancho de la columna
-        with col2:
-            st.markdown("#### Importancia de las Variables (Feature Importance)")
-
-            # Calcular la importancia de las variables (valor absoluto de los coeficientes)
-            coef_abs = np.abs(modelo.coef_)  # Valor absoluto de los coeficientes
-            feature_importance = pd.DataFrame({
-                'Variable': columnas_poly,
-                'Importancia': coef_abs
-            }).sort_values(by='Importancia', ascending=False)  # De mayor a menor
-
-            # Gráfico de barras horizontal con el eje Y invertido
-            fig_importance = go.Figure(go.Bar(
-                y=feature_importance['Variable'],
-                x=feature_importance['Importancia'],
-                orientation='h',
-                marker=dict(color='teal')
-            ))
-            fig_importance.update_layout(
-                title="Importancia de las Variables en el Modelo Cuadrático",
-                xaxis_title="Importancia",
-                yaxis_title="Variables",
-                yaxis=dict(autorange="reversed"),  # Invertir el eje Y
-                margin=dict(l=0, r=0, t=30, b=30)  # Ajustar márgenes
-            )
-            st.plotly_chart(fig_importance, use_container_width=True)
-
-        # Superficies de respuesta dinámicas
-        st.subheader("Superficies de Respuesta")
-
-        # Selector de variables
-        eje_x = st.selectbox("Selecciona la variable para el eje X:", variable_columns, index=0)
-        eje_z = st.selectbox("Selecciona la variable para el eje Z:", variable_columns, index=1)
-
-        # Rango para generar puntos
-        x_range = np.linspace(X[eje_x].min(), X[eje_x].max(), 50)
-        z_range = np.linspace(X[eje_z].min(), X[eje_z].max(), 50)
-        X_grid, Z_grid = np.meshgrid(x_range, z_range)
-
-        # Preparar valores para las otras dos variables
-        otras_variables = [col for col in variable_columns if col not in [eje_x, eje_z]]
-
-        # Crear grilla de predicción con orden de columnas fijo
-        grid_data = []
-        for x_val, z_val in zip(X_grid.ravel(), Z_grid.ravel()):
-            # Crear un diccionario con todas las variables en el orden correcto
-            row_data = dict(zip(variable_columns, [
-                x_val if eje_x == 'Temperatura' else X['Temperatura'].mean(),
-                x_val if eje_x == 'Presión' else (z_val if eje_z == 'Presión' else X['Presión'].mean()),
-                x_val if eje_x == 'Flujo_CO2' else (z_val if eje_z == 'Flujo_CO2' else X['Flujo_CO2'].mean()),
-                x_val if eje_x == 'Tiempo' else (z_val if eje_z == 'Tiempo' else X['Tiempo'].mean())
-            ]))
-            grid_data.append(row_data)
-
-        # Convertir a DataFrame con orden de columnas fijo
-        grid_df = pd.DataFrame(grid_data)[variable_columns]
-
-        # Transformar datos para predicciones
-        grid_poly = poly.transform(grid_df)
-
-        # Predecir valores
-        Y_grid = modelo.predict(grid_poly).reshape(X_grid.shape)
-
-        # Gráfico dinámico con Plotly
-        fig = go.Figure(data=[go.Surface(z=Y_grid, x=X_grid, y=Z_grid, colorscale='Viridis')])
-        fig.update_layout(
-            title=f"Superficie de Respuesta: {eje_x} vs {eje_z} vs Rendimiento",
-            scene=dict(
-                xaxis_title=eje_x,
-                yaxis_title=eje_z,
-                zaxis_title="Rendimiento (%)"
-            )
-        )
-        st.plotly_chart(fig, use_container_width=True)
-
-        # Análisis de sensibilidad
-        st.subheader("Análisis de Sensibilidad")
-        temp = st.slider("Temperatura (°C)", int(X['Temperatura'].min()), int(X['Temperatura'].max()), int(X['Temperatura'].mean()))
-        pres = st.slider("Presión (Bar)", int(X['Presión'].min()), int(X['Presión'].max()), int(X['Presión'].mean()))
-        flujo = st.slider("Flujo CO2 (g/min)", int(X['Flujo_CO2'].min()), int(X['Flujo_CO2'].max()), int(X['Flujo_CO2'].mean()))
-        tiempo = st.slider("Tiempo (h)", int(X['Tiempo'].min()), int(X['Tiempo'].max()), int(X['Tiempo'].mean()))
-
-        # Predicción para los valores seleccionados
-        entrada_sensibilidad = pd.DataFrame({'Temperatura': [temp], 'Presión': [pres], 'Flujo_CO2': [flujo], 'Tiempo': [tiempo]})
-        entrada_poly = poly.transform(entrada_sensibilidad)
-        prediccion = modelo.predict(entrada_poly)
-        st.write(f"**Rendimiento Predicho:** {prediccion[0]:.2f}%")
-
-        # Optimización de puntos mejorada
-        st.subheader("Determinación de Puntos Óptimos")
-        def objetivo(params):
-            """Función objetivo para optimización."""
-            # Transformar parámetros a DataFrame
-            entrada = pd.DataFrame([params], columns=variable_columns)
-            entrada_poly = poly.transform(entrada)
-            return -modelo.predict(entrada_poly)[0]  # Negativo para maximizar
-
-        # Métodos de Optimización
-        st.write("#### Comparación de Métodos de Optimización")
-
-        # Límites de las variables
-        limites = [(X[col].min(), X[col].max()) for col in variable_columns]
-
-        # 1. Optimización por L-BFGS-B (Método Local)
-        #st.write("##### Método L-BFGS-B (Optimización Local)")
-        x0 = [X[col].mean() for col in variable_columns]
-        resultado_lbfgs = minimize(
-            objetivo, 
-            x0=x0, 
-            bounds=limites, 
-            method='L-BFGS-B'
-        )
-        
-        # 2. Evolución Diferencial (Método Global)
-        #st.write("##### Evolución Diferencial (Optimización Global)")
-        resultado_de = differential_evolution(
-            objetivo, 
-            bounds=limites, 
-            strategy='best1bin', 
-            popsize=15, 
-            maxiter=100
-        )
-
-        # 3. Múltiples Inicios Aleatorios
-        #st.write("##### Múltiples Inicios Aleatorios")
-        def multi_start_optimize(num_starts=10):
-            resultados = []
-            for _ in range(num_starts):
-                # Punto inicial aleatorio
-                x0 = [np.random.uniform(low, high) for low, high in limites]
-                
-                resultado = minimize(
-                    objetivo, 
-                    x0=x0, 
-                    bounds=limites, 
-                    method='L-BFGS-B'
-                )
-                resultados.append((resultado, -resultado.fun))
-            
-            # Encontrar el mejor resultado
-            return max(resultados, key=lambda x: x[1])
-
-        resultado_multi = multi_start_optimize()
-
-        # Mostrar resultados de optimización
-        metodos = [
-            ("L-BFGS-B", resultado_lbfgs, -resultado_lbfgs.fun),
-            ("Evolución Diferencial", resultado_de, -resultado_de.fun),
-            ("Múltiples Inicios", resultado_multi[0], resultado_multi[1])
-        ]
-
-        # Tabla comparativa de resultados
-        resultados_df = pd.DataFrame(columns=variable_columns + ['Rendimiento Predicho'])
-        for nombre, resultado, rendimiento in metodos:
-            if resultado.success:
-                fila = pd.DataFrame([list(resultado.x) + [rendimiento]], 
-                                    columns=variable_columns + ['Rendimiento Predicho'])
-                fila.insert(0, 'Método', nombre)
-                resultados_df = pd.concat([resultados_df, fila], ignore_index=True)
-
-        # Mostrar tabla de resultados
-        #st.write("### Comparación de Resultados de Optimización")
-        st.dataframe(resultados_df)
-
-        # Seleccionar el mejor resultado
-        mejor_resultado = resultados_df.loc[resultados_df['Rendimiento Predicho'].idxmax()]
-        st.write("### Punto Óptimo Recomendado")
-        st.write(f"**Método:** {mejor_resultado['Método']}")
-        
-        # Mostrar detalles del mejor punto
-        detalles_optimos = mejor_resultado[variable_columns].to_dict()
-        detalles_str = ", ".join([f"{col}: {val:.2f}" for col, val in detalles_optimos.items()])
-        st.write(f"**Punto Óptimo:** {detalles_str}")
-        st.write(f"**Rendimiento Máximo Predicho:** {mejor_resultado['Rendimiento Predicho']:.2f}%")
-
-        # Análisis de Incertidumbre
-        st.subheader("Análisis de Incertidumbre")
-        
-        # Input para número de bootstraps
-        num_bootstraps = st.number_input(
-            "Número de Bootstraps", 
-            min_value=10, 
-            max_value=1000, 
-            value=100, 
-            step=10,
-            help="Número de remuestreos para el análisis de incertidumbre"
-        )
-        
-        # Botón para realizar análisis de incertidumbre
-        if st.button("Realizar Análisis de Incertidumbre"):
-            with st.spinner('Realizando análisis de bootstrapping...'):
-                # Bootstrap para estimar intervalos de confianza
-                def bootstrap_optimize(num_bootstraps=num_bootstraps):
-                    resultados_bootstrap = []
-                    
-                    for _ in range(num_bootstraps):
-                        # Muestreo con reemplazo
-                        indices = np.random.randint(0, len(X), len(X))
-                        X_boot = X.iloc[indices]
-                        y_boot = y.iloc[indices]
-                        
-                        # Ajustar modelo
-                        poly_boot = PolynomialFeatures(degree=2, include_bias=False)
-                        X_poly_boot = poly_boot.fit_transform(X_boot)
-                        modelo_boot = LinearRegression()
-                        modelo_boot.fit(X_poly_boot, y_boot)
-                        
-                        # Definir nueva función objetivo
-                        def objetivo_boot(params):
-                            entrada = pd.DataFrame([params], columns=variable_columns)
-                            entrada_poly = poly_boot.transform(entrada)
-                            return -modelo_boot.predict(entrada_poly)[0]
-                        
-                        # Optimizar
-                        resultado = differential_evolution(
-                            objetivo_boot, 
-                            bounds=limites, 
-                            strategy='best1bin', 
-                            popsize=15, 
-                            maxiter=100
-                        )
-                        
-                        resultados_bootstrap.append({
-                            'Punto': resultado.x,
-                            'Rendimiento': -resultado.fun
-                        })
-                    
-                    return resultados_bootstrap
-
-                # Realizar bootstrap
-                resultados_bootstrap = bootstrap_optimize()
-                
-                # Convertir a DataFrame
-                bootstrap_df = pd.DataFrame(resultados_bootstrap)
-                
-                # Calcular intervalos de confianza
-                intervalos_confianza = {}
-                for i, col in enumerate(variable_columns):
-                    intervalos_confianza[col] = (
-                        np.percentile(bootstrap_df['Punto'].apply(lambda x: x[i]), 2.5),
-                        np.percentile(bootstrap_df['Punto'].apply(lambda x: x[i]), 97.5)
-                    )
-                
-                # Mostrar intervalos de confianza
-                st.write("### Intervalos de Confianza (95%)")
-                for col, (min_val, max_val) in intervalos_confianza.items():
-                    st.write(f"**{col}:** [{min_val:.2f}, {max_val:.2f}]")
-                
-                # Distribución de rendimientos
-                st.write("### Distribución de Rendimientos en Bootstrap")
-                fig_bootstrap = plt.figure(figsize=(10, 6))
-                plt.hist(bootstrap_df['Rendimiento'], bins=30, edgecolor='black')
-                plt.title(f'Distribución de Rendimientos Predichos (Bootstrap: {num_bootstraps})')
-                plt.xlabel('Rendimiento (%)')
-                plt.ylabel('Frecuencia')
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from scipy.optimize import minimize, differential_evolution
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error, r2_score
+import matplotlib.pyplot as plt
+import seaborn as sns
+import io
+# Configuración inicial
+# Configuración de la aplicación
+st.set_page_config(page_title="Optimización Avanzada", page_icon="📊",layout="wide")
+# Display the image above the title
+st.image('cannabis.jpg')
+st.title("Optimización Avanzada con Diseño Experimental Box-Behnken")
+st.write("Aplicación con regresión cuadrática y estrategias de optimización mejoradas.")
+
+# Crear las pestañas
+tabs = st.selectbox("Selecciona una opción", ["Fundamento Teórico", "Aplicación Interactiva"])
+
+if tabs == "Fundamento Teórico":
+    st.header("Fundamento Teórico")
+    
+    # Imagen del proceso
+    st.subheader("Proceso de Extracción de CBD")
+    st.image("CBD extraction process.png", caption="Proceso de Extracción de CBD con CO2 Supercrítico", use_container_width=True)
+    st.write("""
+    El proceso de extracción de CBD utiliza tecnología de CO2 supercrítico debido a su eficiencia y capacidad para producir extractos puros. Este método incluye etapas clave como molienda, extracción, separación y refinamiento, garantizando un producto de alta calidad para aplicaciones medicinales y comerciales.
+    """)
+
+    # Diseño Experimental Box-Behnken
+    st.subheader("Diseño Experimental Box-Behnken")
+    st.write("""
+    El diseño experimental **Box-Behnken** se utiliza para modelar y optimizar procesos complejos. En este caso, se aplica para maximizar el rendimiento de CBD considerando variables clave como **Temperatura**, **Presión**, **Flujo de CO2** y **Tiempo**.
+    Este enfoque reduce significativamente la cantidad de experimentos necesarios, permitiendo explorar interacciones no lineales de manera eficiente.
+    """)
+
+    # Proceso de Producción de CBD
+    st.subheader("Proceso de Producción de CBD")
+    st.write("""
+    Según el documento *Optimization of Supercritical Carbon Dioxide Fluid Extraction of Medicinal Cannabis from Quebec*, el proceso de extracción con CO2 supercrítico es preferido por su alta selectividad y pureza. Las principales etapas incluyen:
+    1. **Preparación de la materia prima**: Molienda y acondicionamiento.
+    2. **Extracción supercrítica**:
+        - El CO2 actúa como solvente bajo condiciones controladas de presión y temperatura.
+        - Variables clave: presión (150-320 bar), temperatura (40-70°C), flujo de CO2 (5-15 g/min), tiempo (2-4 horas).
+    3. **Separación y recolección**: El CO2 se despresuriza para liberar los cannabinoides extraídos.
+    4. **Refinamiento posterior**: Remoción de ceras y otros compuestos no deseados.
+    """)
+
+    # Caso de Negocio
+    st.subheader("Caso de Negocio: Optimización del Rendimiento")
+    st.write("""
+    Optimizar el rendimiento del proceso de extracción permite:
+    - Maximizar la cantidad de CBD extraído por lote.
+    - Reducir costos operativos (energía, solventes, tiempo).
+    - Mejorar la calidad del producto final.
+    
+    Este enfoque es crucial en la industria del cannabis medicinal, donde la eficiencia del proceso impacta directamente en la rentabilidad y sostenibilidad del negocio.
+    """)
+
+    # Método Basado en CRISP-DM
+    st.subheader("Metodología Basada en CRISP-DM")
+    st.write("""
+    La metodología **CRISP-DM** estructura el desarrollo del modelo en seis etapas:
+    1. **Comprensión del Negocio**: Definir objetivos y restricciones del proceso.
+    2. **Comprensión de los Datos**: Analizar datos experimentales y evaluar su calidad.
+    3. **Preparación de los Datos**: Limpiar y transformar datos para el modelado.
+    4. **Modelado**: Ajustar un modelo de regresión cuadrática para capturar relaciones no lineales.
+    5. **Evaluación**: Validar el modelo y analizar su desempeño.
+    6. **Despliegue**: Implementar el modelo en una aplicación interactiva para optimización en tiempo real.
+    """)
+
+    # Optimización
+    st.subheader("Optimización")
+    st.write("""
+    Se emplean técnicas avanzadas para maximizar el rendimiento:
+    - **L-BFGS-B**: Método de optimización local.
+    - **Evolución Diferencial**: Optimización global para evitar óptimos locales.
+    - **Múltiples inicios aleatorios**: Combina estrategias locales y globales para robustez.
+    """)
+
+    # Referencias
+    st.subheader("Referencias")
+    st.write("""
+    - [Optimization of Supercritical Carbon Dioxide Fluid Extraction of Medicinal Cannabis from Quebec](https://www.mdpi.com/2227-9717/11/7/1953).
+    - Herrero, M., Cifuentes, A., & Ibañez, E. (2006). Supercritical fluid extraction: Recent advances and applications. *Journal of Chromatography A*, 1131(1), 1–24.
+    - Turner, C., Mathiasson, L., & Lewis, G. (2001). Supercritical fluid extraction and chromatography. *Journal of Biochemical Analysis*, 121(3), 35–58.
+    """)
+
+elif tabs == "Aplicación Interactiva":
+    st.header("Aplicación Interactiva")
+    st.write("A continuación, puedes cargar tus datos, realizar predicciones y optimizar el rendimiento del proceso de extracción de cannabinoides.")
+
+    # Opciones de selección de datos de ejemplo
+    st.subheader("Datos de Ejemplo")
+    usar_datos_exp = st.checkbox("Usar datos de ejemplo: datos_exp.csv")
+    usar_datos_process = st.checkbox("Usar datos de ejemplo: datos_process.csv")
+
+    # Inicializar variable de datos
+    data = None
+
+    # Verificar qué checkbox está seleccionado y cargar el archivo correspondiente
+    if usar_datos_exp and not usar_datos_process:
+        data = pd.read_csv("data_exp.csv")
+        st.success("Datos de ejemplo (datos_exp.csv) cargados exitosamente.")
+        st.dataframe(data, use_container_width=True)  # Ajustar al ancho de la app
+    elif usar_datos_process and not usar_datos_exp:
+        data = pd.read_csv("data_process.csv")
+        st.success("Datos de ejemplo (datos_process.csv) cargados exitosamente.")
+        st.dataframe(data, use_container_width=True)  # Ajustar al ancho de la app
+    elif usar_datos_exp and usar_datos_process:
+        st.error("Por favor, selecciona solo un conjunto de datos de ejemplo a la vez.")
+    
+    # Opción para cargar datos personalizados
+    st.subheader("Carga tus Datos")
+    uploaded_file = st.file_uploader("Carga un archivo CSV con los datos experimentales:", type="csv")
+
+    if uploaded_file is not None:
+        # Leer datos cargados
+        data = pd.read_csv(uploaded_file)
+        st.success("Datos cargados exitosamente desde el archivo proporcionado.")
+        st.dataframe(data, use_container_width=True)  # Ajustar al ancho de la app
+
+    # Validación para asegurarse de que se cargaron datos
+    if data is None:
+        st.warning("No se han cargado datos. Por favor, selecciona un archivo o usa datos de ejemplo.")
+    else:
+        st.write("### Datos listos para su análisis.")
+
+        # Definir el orden fijo de variables
+        variable_columns = ['Temperatura', 'Presión', 'Flujo_CO2', 'Tiempo']
+
+        # Extraer variables independientes y dependiente en el orden correcto
+        X = data[variable_columns]
+        y = data['Rendimiento']
+
+        # Generar términos cuadráticos (regresión polinómica de segundo grado)
+        poly = PolynomialFeatures(degree=2, include_bias=False)
+        X_poly = poly.fit_transform(X)
+        columnas_poly = poly.get_feature_names_out(X.columns)
+
+        # Ajustar modelo cuadrático
+        modelo = LinearRegression()
+        modelo.fit(X_poly, y)
+
+        # Predicciones del modelo
+        y_pred = modelo.predict(X_poly)
+
+        # Evaluación del modelo
+        st.subheader("Evaluación del Modelo Cuadrático")
+        st.write(f"**Error Cuadrático Medio (MSE):** {mean_squared_error(y, y_pred):.4f}")
+        st.write(f"**R² (Coeficiente de Determinación):** {r2_score(y, y_pred):.4f}")
+
+        # Resumen del modelo: coeficientes
+
+        # Visualización paralela usando columnas
+        col1, col2 = st.columns(2)
+
+        # En la columna 1, mostrar el DataFrame con términos y coeficientes, adaptado al ancho de la columna
+        with col1:
+            st.markdown("#### Términos y Coeficientes del Modelo")
+
+            # Crear un DataFrame con los coeficientes
+            coeficientes = pd.DataFrame({
+                'Término': columnas_poly, 
+                'Coeficiente': modelo.coef_
+            })
+            
+            coeficientes = coeficientes.sort_values(by='Coeficiente', ascending=False)
+            
+            # Función para aplicar colores a los coeficientes
+            def color_coef(val):
+                color = 'red' if val > 0 else 'blue'  # Los coeficientes positivos serán rojos, negativos azules
+                return f'background-color: {color}; color: white;'
+
+            # Aplicar estilo a la columna 'Coeficiente' para colorear los valores
+            styled_coef = coeficientes.style.applymap(color_coef, subset=['Coeficiente'])
+
+            # Mostrar el DataFrame estilizado y ajustado al ancho de la columna
+            st.dataframe(styled_coef, use_container_width=True)
+
+        # En la columna 2, mostrar el gráfico de importancia de las variables, adaptado al ancho de la columna
+        with col2:
+            st.markdown("#### Importancia de las Variables (Feature Importance)")
+
+            # Calcular la importancia de las variables (valor absoluto de los coeficientes)
+            coef_abs = np.abs(modelo.coef_)  # Valor absoluto de los coeficientes
+            feature_importance = pd.DataFrame({
+                'Variable': columnas_poly,
+                'Importancia': coef_abs
+            }).sort_values(by='Importancia', ascending=False)  # De mayor a menor
+
+            # Gráfico de barras horizontal con el eje Y invertido
+            fig_importance = go.Figure(go.Bar(
+                y=feature_importance['Variable'],
+                x=feature_importance['Importancia'],
+                orientation='h',
+                marker=dict(color='teal')
+            ))
+            fig_importance.update_layout(
+                title="Importancia de las Variables en el Modelo Cuadrático",
+                xaxis_title="Importancia",
+                yaxis_title="Variables",
+                yaxis=dict(autorange="reversed"),  # Invertir el eje Y
+                margin=dict(l=0, r=0, t=30, b=30)  # Ajustar márgenes
+            )
+            st.plotly_chart(fig_importance, use_container_width=True)
+
+        # Superficies de respuesta dinámicas
+        st.subheader("Superficies de Respuesta")
+
+        # Selector de variables
+        eje_x = st.selectbox("Selecciona la variable para el eje X:", variable_columns, index=0)
+        eje_z = st.selectbox("Selecciona la variable para el eje Z:", variable_columns, index=1)
+
+        # Rango para generar puntos
+        x_range = np.linspace(X[eje_x].min(), X[eje_x].max(), 50)
+        z_range = np.linspace(X[eje_z].min(), X[eje_z].max(), 50)
+        X_grid, Z_grid = np.meshgrid(x_range, z_range)
+
+        # Preparar valores para las otras dos variables
+        otras_variables = [col for col in variable_columns if col not in [eje_x, eje_z]]
+
+        # Crear grilla de predicción con orden de columnas fijo
+        grid_data = []
+        for x_val, z_val in zip(X_grid.ravel(), Z_grid.ravel()):
+            # Crear un diccionario con todas las variables en el orden correcto
+            row_data = dict(zip(variable_columns, [
+                x_val if eje_x == 'Temperatura' else X['Temperatura'].mean(),
+                x_val if eje_x == 'Presión' else (z_val if eje_z == 'Presión' else X['Presión'].mean()),
+                x_val if eje_x == 'Flujo_CO2' else (z_val if eje_z == 'Flujo_CO2' else X['Flujo_CO2'].mean()),
+                x_val if eje_x == 'Tiempo' else (z_val if eje_z == 'Tiempo' else X['Tiempo'].mean())
+            ]))
+            grid_data.append(row_data)
+
+        # Convertir a DataFrame con orden de columnas fijo
+        grid_df = pd.DataFrame(grid_data)[variable_columns]
+
+        # Transformar datos para predicciones
+        grid_poly = poly.transform(grid_df)
+
+        # Predecir valores
+        Y_grid = modelo.predict(grid_poly).reshape(X_grid.shape)
+
+        # Gráfico dinámico con Plotly
+        fig = go.Figure(data=[go.Surface(z=Y_grid, x=X_grid, y=Z_grid, colorscale='Viridis')])
+        fig.update_layout(
+            title=f"Superficie de Respuesta: {eje_x} vs {eje_z} vs Rendimiento",
+            scene=dict(
+                xaxis_title=eje_x,
+                yaxis_title=eje_z,
+                zaxis_title="Rendimiento (%)"
+            )
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+        # Análisis de sensibilidad
+        st.subheader("Análisis de Sensibilidad")
+        temp = st.slider("Temperatura (°C)", int(X['Temperatura'].min()), int(X['Temperatura'].max()), int(X['Temperatura'].mean()))
+        pres = st.slider("Presión (Bar)", int(X['Presión'].min()), int(X['Presión'].max()), int(X['Presión'].mean()))
+        flujo = st.slider("Flujo CO2 (g/min)", int(X['Flujo_CO2'].min()), int(X['Flujo_CO2'].max()), int(X['Flujo_CO2'].mean()))
+        tiempo = st.slider("Tiempo (h)", int(X['Tiempo'].min()), int(X['Tiempo'].max()), int(X['Tiempo'].mean()))
+
+        # Predicción para los valores seleccionados
+        entrada_sensibilidad = pd.DataFrame({'Temperatura': [temp], 'Presión': [pres], 'Flujo_CO2': [flujo], 'Tiempo': [tiempo]})
+        entrada_poly = poly.transform(entrada_sensibilidad)
+        prediccion = modelo.predict(entrada_poly)
+        st.write(f"**Rendimiento Predicho:** {prediccion[0]:.2f}%")
+
+        # Optimización de puntos mejorada
+        st.subheader("Determinación de Puntos Óptimos")
+        def objetivo(params):
+            """Función objetivo para optimización."""
+            # Transformar parámetros a DataFrame
+            entrada = pd.DataFrame([params], columns=variable_columns)
+            entrada_poly = poly.transform(entrada)
+            return -modelo.predict(entrada_poly)[0]  # Negativo para maximizar
+
+        # Métodos de Optimización
+        st.write("#### Comparación de Métodos de Optimización")
+
+        # Límites de las variables
+        limites = [(X[col].min(), X[col].max()) for col in variable_columns]
+
+        # 1. Optimización por L-BFGS-B (Método Local)
+        #st.write("##### Método L-BFGS-B (Optimización Local)")
+        x0 = [X[col].mean() for col in variable_columns]
+        resultado_lbfgs = minimize(
+            objetivo, 
+            x0=x0, 
+            bounds=limites, 
+            method='L-BFGS-B'
+        )
+        
+        # 2. Evolución Diferencial (Método Global)
+        #st.write("##### Evolución Diferencial (Optimización Global)")
+        resultado_de = differential_evolution(
+            objetivo, 
+            bounds=limites, 
+            strategy='best1bin', 
+            popsize=15, 
+            maxiter=100
+        )
+
+        # 3. Múltiples Inicios Aleatorios
+        #st.write("##### Múltiples Inicios Aleatorios")
+        def multi_start_optimize(num_starts=10):
+            resultados = []
+            for _ in range(num_starts):
+                # Punto inicial aleatorio
+                x0 = [np.random.uniform(low, high) for low, high in limites]
+                
+                resultado = minimize(
+                    objetivo, 
+                    x0=x0, 
+                    bounds=limites, 
+                    method='L-BFGS-B'
+                )
+                resultados.append((resultado, -resultado.fun))
+            
+            # Encontrar el mejor resultado
+            return max(resultados, key=lambda x: x[1])
+
+        resultado_multi = multi_start_optimize()
+
+        # Mostrar resultados de optimización
+        metodos = [
+            ("L-BFGS-B", resultado_lbfgs, -resultado_lbfgs.fun),
+            ("Evolución Diferencial", resultado_de, -resultado_de.fun),
+            ("Múltiples Inicios", resultado_multi[0], resultado_multi[1])
+        ]
+
+        # Tabla comparativa de resultados
+        resultados_df = pd.DataFrame(columns=variable_columns + ['Rendimiento Predicho'])
+        for nombre, resultado, rendimiento in metodos:
+            if resultado.success:
+                fila = pd.DataFrame([list(resultado.x) + [rendimiento]], 
+                                    columns=variable_columns + ['Rendimiento Predicho'])
+                fila.insert(0, 'Método', nombre)
+                resultados_df = pd.concat([resultados_df, fila], ignore_index=True)
+
+        # Mostrar tabla de resultados
+        #st.write("### Comparación de Resultados de Optimización")
+        st.dataframe(resultados_df)
+
+        # Seleccionar el mejor resultado
+        mejor_resultado = resultados_df.loc[resultados_df['Rendimiento Predicho'].idxmax()]
+        st.write("### Punto Óptimo Recomendado")
+        st.write(f"**Método:** {mejor_resultado['Método']}")
+        
+        # Mostrar detalles del mejor punto
+        detalles_optimos = mejor_resultado[variable_columns].to_dict()
+        detalles_str = ", ".join([f"{col}: {val:.2f}" for col, val in detalles_optimos.items()])
+        st.write(f"**Punto Óptimo:** {detalles_str}")
+        st.write(f"**Rendimiento Máximo Predicho:** {mejor_resultado['Rendimiento Predicho']:.2f}%")
+
+        # Análisis de Incertidumbre
+        st.subheader("Análisis de Incertidumbre")
+        
+        # Input para número de bootstraps
+        num_bootstraps = st.number_input(
+            "Número de Bootstraps", 
+            min_value=10, 
+            max_value=1000, 
+            value=100, 
+            step=10,
+            help="Número de remuestreos para el análisis de incertidumbre"
+        )
+        
+        # Botón para realizar análisis de incertidumbre
+        if st.button("Realizar Análisis de Incertidumbre"):
+            with st.spinner('Realizando análisis de bootstrapping...'):
+                # Bootstrap para estimar intervalos de confianza
+                def bootstrap_optimize(num_bootstraps=num_bootstraps):
+                    resultados_bootstrap = []
+                    
+                    for _ in range(num_bootstraps):
+                        # Muestreo con reemplazo
+                        indices = np.random.randint(0, len(X), len(X))
+                        X_boot = X.iloc[indices]
+                        y_boot = y.iloc[indices]
+                        
+                        # Ajustar modelo
+                        poly_boot = PolynomialFeatures(degree=2, include_bias=False)
+                        X_poly_boot = poly_boot.fit_transform(X_boot)
+                        modelo_boot = LinearRegression()
+                        modelo_boot.fit(X_poly_boot, y_boot)
+                        
+                        # Definir nueva función objetivo
+                        def objetivo_boot(params):
+                            entrada = pd.DataFrame([params], columns=variable_columns)
+                            entrada_poly = poly_boot.transform(entrada)
+                            return -modelo_boot.predict(entrada_poly)[0]
+                        
+                        # Optimizar
+                        resultado = differential_evolution(
+                            objetivo_boot, 
+                            bounds=limites, 
+                            strategy='best1bin', 
+                            popsize=15, 
+                            maxiter=100
+                        )
+                        
+                        resultados_bootstrap.append({
+                            'Punto': resultado.x,
+                            'Rendimiento': -resultado.fun
+                        })
+                    
+                    return resultados_bootstrap
+
+                # Realizar bootstrap
+                resultados_bootstrap = bootstrap_optimize()
+                
+                # Convertir a DataFrame
+                bootstrap_df = pd.DataFrame(resultados_bootstrap)
+                
+                # Calcular intervalos de confianza
+                intervalos_confianza = {}
+                for i, col in enumerate(variable_columns):
+                    intervalos_confianza[col] = (
+                        np.percentile(bootstrap_df['Punto'].apply(lambda x: x[i]), 2.5),
+                        np.percentile(bootstrap_df['Punto'].apply(lambda x: x[i]), 97.5)
+                    )
+                
+                # Mostrar intervalos de confianza
+                st.write("### Intervalos de Confianza (95%)")
+                for col, (min_val, max_val) in intervalos_confianza.items():
+                    st.write(f"**{col}:** [{min_val:.2f}, {max_val:.2f}]")
+                
+                # Distribución de rendimientos
+                st.write("### Distribución de Rendimientos en Bootstrap")
+                fig_bootstrap = plt.figure(figsize=(10, 6))
+                plt.hist(bootstrap_df['Rendimiento'], bins=30, edgecolor='black')
+                plt.title(f'Distribución de Rendimientos Predichos (Bootstrap: {num_bootstraps})')
+                plt.xlabel('Rendimiento (%)')
+                plt.ylabel('Frecuencia')
                 st.pyplot(fig_bootstrap)