app.py

import numpy as np
import pandas as pd
import statsmodels.formula.api as smf
import statsmodels.api as sm
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from scipy.optimize import minimize
import plotly.express as px
from scipy.stats import t
import gradio as gr

class RSM_BoxBehnken:
    # ... (Tu código de la clase RSM_BoxBehnken se mantiene igual) ...

# Crear un DataFrame a partir de la tabla
data = pd.DataFrame({
    'Exp.': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
    'Glucosa': [-1, 1, -1, 1, -1, 1, -1, 1, 0, 0, 0, 0, 0, 0, 0],
    'Extracto de Levadura': [-1, -1, 1, 1, 0, 0, 0, 0, -1, 1, -1, 1, 0, 0, 0],
    'Triptófano': [0, 0, 0, 0, -1, -1, 1, 1, -1, -1, 1, 1, 0, 0, 0],
    'AIA (ppm)': [166.594, 177.557, 127.261, 147.573, 188.883, 224.527, 190.238, 226.483, 195.550, 149.493, 187.683, 148.621, 278.951, 297.238, 280.896]
})

# Crear una instancia de la clase RSM_BoxBehnken
rsm = RSM_BoxBehnken(data)

# --- Funciones para la interfaz de Gradio ---

def fit_full_model():
    rsm.fit_model()
    return "Modelo completo ajustado. Revisa la consola para ver el resumen."

def fit_simplified_model():
    rsm.fit_simplified_model()
    return "Modelo simplificado ajustado. Revisa la consola para ver el resumen."

def optimize_model(method):
    rsm.optimize(method)
    return (f"Optimización realizada con {method}. Revisa la consola para ver los niveles óptimos.\n"
            f"Niveles óptimos (codificados): {rsm.optimal_levels}\n"
            f"Valor máximo de {rsm.y_name}: {-rsm.optimized_results.fun:.4f}")

def generate_plot(fixed_variable, fixed_level_natural):
    fig = rsm.plot_rsm_individual(fixed_variable, fixed_level_natural)
    if fig is not None:
        return fig
    else:
        return "Ajusta el modelo simplificado primero."

# --- Creación de la interfaz de Gradio ---

with gr.Blocks() as demo:
    gr.Markdown("# Análisis de Superficie de Respuesta (RSM) - Diseño Box-Behnken")

    with gr.Tab("Ajuste de Modelos"):
        with gr.Row():
            full_model_button = gr.Button("Ajustar Modelo Completo")
            simplified_model_button = gr.Button("Ajustar Modelo Simplificado")
        model_output = gr.Textbox(label="Resultado del Ajuste")

        full_model_button.click(fn=fit_full_model, outputs=model_output)
        simplified_model_button.click(fn=fit_simplified_model, outputs=model_output)

    with gr.Tab("Optimización"):
        method_dropdown = gr.Dropdown(
            choices=['Nelder-Mead', 'Powell', 'BFGS'],
            value='Nelder-Mead',
            label="Método de Optimización"
        )
        optimize_button = gr.Button("Optimizar")
        optimization_output = gr.Textbox(label="Resultado de la Optimización")

        optimize_button.click(fn=optimize_model, inputs=method_dropdown, outputs=optimization_output)

    with gr.Tab("Gráficos de Superficie de Respuesta"):
        with gr.Row():
            fixed_variable_dropdown = gr.Dropdown(
                choices=[rsm.x1_name, rsm.x2_name, rsm.x3_name],
                value=rsm.x1_name,
                label="Variable Fija"
            )
            fixed_level_slider = gr.Slider(
                minimum=min(rsm.get_levels(rsm.x1_name)),
                maximum=max(rsm.get_levels(rsm.x1_name)),
                step=0.01,
                value=rsm.get_levels(rsm.x1_name)[1],
                label="Nivel de Variable Fija (Natural)"
            )
        plot_button = gr.Button("Generar Gráfico")
        plot_output = gr.Plot(label="Gráfico RSM")

        def update_slider_range(fixed_variable):
            levels = rsm.get_levels(fixed_variable)
            return gr.Slider.update(minimum=min(levels), maximum=max(levels), value=levels[1])

        fixed_variable_dropdown.change(
            fn=update_slider_range,
            inputs=fixed_variable_dropdown,
            outputs=fixed_level_slider
        )
        plot_button.click(
            fn=generate_plot,
            inputs=[fixed_variable_dropdown, fixed_level_slider],
            outputs=plot_output
        )

demo.launch()