Upload 6 files

app.py

@@ -0,0 +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')
+                st.pyplot(fig_bootstrap)

data_exp.csv

@@ -0,0 +1,28 @@
+Run,Temperatura,Presión,Flujo_CO2,Tiempo,Rendimiento
+1,40,150,10,3,11.1
+2,70,150,10,3,18.2
+3,40,320,10,3,11.6
+4,70,320,10,3,22.9
+5,55,235,5,2,7.4
+6,55,235,15,2,22.7
+7,55,235,5,4,16.0
+8,55,235,15,4,25.9
+9,55,235,10,3,11.3
+10,40,235,10,2,15.2
+11,70,320,10,2,18.0
+12,40,235,10,4,21.1
+13,70,235,10,4,21.7
+14,55,150,5,3,12.0
+15,55,320,5,3,11.0
+16,55,150,15,3,6.7
+17,55,320,15,3,19.0
+18,55,235,10,4,9.3
+19,40,235,5,3,12.1
+20,70,235,5,3,8.5
+21,40,320,15,3,19.5
+22,70,235,15,3,12.7
+23,55,150,10,2,2.4
+24,55,320,10,2,16.2
+25,55,150,10,4,11.0
+26,55,320,10,4,24.9
+27,55,235,10,3,12.2

data_process.csv

@@ -0,0 +1,20 @@
+Timestamp,Temperatura,Presión,Flujo_CO2,Tiempo,Rendimiento
+2023-12-01 08:00:00,54.1,275.3,11.4,3.4,18.7
+2023-12-01 08:05:00,66.8,262.6,9.8,3.7,22.5
+2023-12-01 08:10:00,43.6,166.3,12.7,2.5,15.6
+2023-12-01 08:15:00,44.9,271.4,12.4,2.7,11.2
+2023-12-01 08:20:00,48.5,292.1,11.6,2.9,7.9
+2023-12-01 08:25:00,64.1,189.3,12.1,2.6,16.8
+2023-12-01 08:30:00,44.4,216.8,13.2,2.8,6.7
+2023-12-01 08:35:00,58.9,174.6,11.8,2.3,14.5
+2023-12-01 08:40:00,57.8,297.6,13.7,3.5,8.1
+2023-12-01 08:45:00,48.6,307.2,7.2,3.6,5.3
+2023-12-01 08:50:00,58.2,159.7,9.6,3.4,23.5
+2023-12-01 08:55:00,52.9,198.4,11.5,2.9,17.9
+2023-12-01 09:00:00,42.8,273.2,10.2,3.7,10.3
+2023-12-01 09:05:00,50.1,312.4,14.9,3.2,19.3
+2023-12-01 09:10:00,62.9,299.3,14.2,2.7,11.7
+2023-12-01 09:15:00,67.3,211.2,10.6,3.0,14.1
+2023-12-01 09:20:00,43.5,177.6,6.1,3.6,12.8
+2023-12-01 09:25:00,64.4,312.7,6.5,3.2,20.3
+2023-12-01 09:30:00,44.8,295.1,8.7,3.3,24.6

requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+pandas
+numpy
+statsmodels
+plotly