Update interface.py

interface.py

@@ -12,30 +12,37 @@ from transformers import AutoTokenizer, AutoModelForCausalLM
 from sympy import symbols, sympify, lambdify
 import copy
 from config import DEVICE, MODEL_PATH, MAX_LENGTH, TEMPERATURE
-from decorators import spaces  # Import the spaces class
 
+# Configuración del dispositivo
 device = DEVICE
-model_path = MODEL_PATH
+
+# Cargar el modelo
+model_path = MODEL_PATH  # Reemplaza con la ruta real de tu modelo
 tokenizer = AutoTokenizer.from_pretrained(model_path)
-model = AutoModelForCausalLM.from_pretrained(model_path).to(device).eval()
+model = AutoModelForCausalLM.from_pretrained(model_path)
+model.to(device)
+model.eval()
 
-@spaces.GPU(duration=100)  # Apply the GPU decorator
+@torch.no_grad()
 def generate_analysis(prompt, max_length=MAX_LENGTH):
     try:
         input_ids = tokenizer.encode(prompt, return_tensors='pt').to(device)
+        max_gen_length = min(max_length + input_ids.size(1), model.config.max_position_embeddings)
+
         generated_ids = model.generate(
             input_ids=input_ids,
-            max_length=max_length + len(input_ids[0]),
+            max_length=max_gen_length,
             temperature=TEMPERATURE,
             num_return_sequences=1,
             no_repeat_ngram_size=2,
             early_stopping=True
         )
+
         output_text = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
         analysis = output_text[len(prompt):].strip()
         return analysis
     except Exception as e:
-        return f"An error occurred during analysis: {e}"
+        return f"Ocurrió un error durante el análisis: {e}"
 
 def parse_bounds(bounds_str, num_params):
     try:
@@ -50,404 +57,21 @@ def parse_bounds(bounds_str, num_params):
         upper_bounds = [np.inf] * num_params
         return lower_bounds, upper_bounds
 
-@spaces.GPU(duration=100)
+# Aquí incluye la función process_and_plot completa, asegurándote de que no haya referencias a decorators o @spaces.GPU
+
 def process_and_plot(
     file,
-    biomass_eq1, biomass_eq2, biomass_eq3,
-    biomass_param1, biomass_param2, biomass_param3,
-    biomass_bound1, biomass_bound2, biomass_bound3,
-    substrate_eq1, substrate_eq2, substrate_eq3,
-    substrate_param1, substrate_param2, substrate_param3,
-    substrate_bound1, substrate_bound2, substrate_bound3,
-    product_eq1, product_eq2, product_eq3,
-    product_param1, product_param2, product_param3,
-    product_bound1, product_bound2, product_bound3,
-    legend_position,
-    show_legend,
-    show_params,
-    biomass_eq_count,
-    substrate_eq_count,
-    product_eq_count
+    # Lista completa de parámetros según tu código
+    # Asegúrate de que coincida con los inputs en UI.py
 ):
-    biomass_eqs = [biomass_eq1, biomass_eq2, biomass_eq3][:biomass_eq_count]
-    biomass_params = [biomass_param1, biomass_param2, biomass_param3][:biomass_eq_count]
-    biomass_bounds = [biomass_bound1, biomass_bound2, biomass_bound3][:biomass_eq_count]
-
-    substrate_eqs = [substrate_eq1, substrate_eq2, substrate_eq3][:substrate_eq_count]
-    substrate_params = [substrate_param1, substrate_param2, substrate_param3][:substrate_eq_count]
-    substrate_bounds = [substrate_bound1, substrate_bound2, substrate_bound3][:substrate_eq_count]
-
-    product_eqs = [product_eq1, product_eq2, product_eq3][:product_eq_count]
-    product_params = [product_param1, product_param2, product_param3][:product_eq_count]
-    product_bounds = [product_bound1, product_bound2, product_bound3][:product_eq_count]
-
-    df = pd.read_excel(file.name)
-    time = df['Time'].values
-    biomass_data = df['Biomass'].values
-    substrate_data = df['Substrate'].values
-    product_data = df['Product'].values
-
-    biomass_results = []
-    substrate_results = []
-    product_results = []
-
-    for i in range(len(biomass_eqs)):
-        equation = biomass_eqs[i]
-        params_str = biomass_params[i]
-        bounds_str = biomass_bounds[i]
-
-        model = BioprocessModel()
-        model.set_model('biomass', equation, params_str)
-
-        params = [param.strip() for param in params_str.split(',')]
-        lower_bounds, upper_bounds = parse_bounds(bounds_str, len(params))
-
-        y_pred = model.fit_model(
-            'biomass', time, biomass_data,
-            bounds=(lower_bounds, upper_bounds)
-        )
-        biomass_results.append({
-            'model': copy.deepcopy(model),
-            'y_pred': y_pred,
-            'equation': equation
-        })
-
-    biomass_model = biomass_results[0]['model']
-    X_t = biomass_model.models['biomass']['function']
-    biomass_params_values = list(biomass_model.params['biomass'].values())
-
-    for i in range(len(substrate_eqs)):
-        equation = substrate_eqs[i]
-        params_str = substrate_params[i]
-        bounds_str = substrate_bounds[i]
-
-        model = BioprocessModel()
-
-        t_symbol = symbols('t')
-        expr_substrate = sympify(equation)
-        substrate_params_symbols = symbols([param.strip() for param in params_str.split(',')])
-        substrate_func = lambdify(
-            (t_symbol, *substrate_params_symbols),
-            expr_substrate.subs('X(t)', X_t(t_symbol, *biomass_params_values)),
-            'numpy'
-        )
-        model.models['substrate'] = {
-            'function': substrate_func,
-            'params': [param.strip() for param in params_str.split(',')]
-        }
-
-        params = model.models['substrate']['params']
-        lower_bounds, upper_bounds = parse_bounds(bounds_str, len(params))
-
-        y_pred = model.fit_model(
-            'substrate', time, substrate_data,
-            bounds=(lower_bounds, upper_bounds)
-        )
-        substrate_results.append({
-            'model': copy.deepcopy(model),
-            'y_pred': y_pred,
-            'equation': equation
-        })
-
-    for i in range(len(product_eqs)):
-        equation = product_eqs[i]
-        params_str = product_params[i]
-        bounds_str = product_bounds[i]
-
-        model = BioprocessModel()
-
-        t_symbol = symbols('t')
-        expr_product = sympify(equation)
-        product_params_symbols = symbols([param.strip() for param in params_str.split(',')])
-        product_func = lambdify(
-            (t_symbol, *product_params_symbols),
-            expr_product.subs('X(t)', X_t(t_symbol, *biomass_params_values)),
-            'numpy'
-        )
-        model.models['product'] = {
-            'function': product_func,
-            'params': [param.strip() for param in params_str.split(',')]
-        }
-
-        params = model.models['product']['params']
-        lower_bounds, upper_bounds = parse_bounds(bounds_str, len(params))
-
-        y_pred = model.fit_model(
-            'product', time, product_data,
-            bounds=(lower_bounds, upper_bounds)
-        )
-        product_results.append({
-            'model': copy.deepcopy(model),
-            'y_pred': y_pred,
-            'equation': equation
-        })
-
-    fig, axs = plt.subplots(3, 1, figsize=(10, 15))
-
-    # Biomass Plot
-    axs[0].plot(time, biomass_data, 'o', label='Biomass Data')
-    for i, result in enumerate(biomass_results):
-        axs[0].plot(time, result['y_pred'], '-', label=f'Biomass Model {i+1}')
-    axs[0].set_xlabel('Time')
-    axs[0].set_ylabel('Biomass')
-    if show_legend:
-        axs[0].legend(loc=legend_position)
-
-    # Substrate Plot
-    axs[1].plot(time, substrate_data, 'o', label='Substrate Data')
-    for i, result in enumerate(substrate_results):
-        axs[1].plot(time, result['y_pred'], '-', label=f'Substrate Model {i+1}')
-    axs[1].set_xlabel('Time')
-    axs[1].set_ylabel('Substrate')
-    if show_legend:
-        axs[1].legend(loc=legend_position)
-
-    # Product Plot
-    axs[2].plot(time, product_data, 'o', label='Product Data')
-    for i, result in enumerate(product_results):
-        axs[2].plot(time, result['y_pred'], '-', label=f'Product Model {i+1}')
-    axs[2].set_xlabel('Time')
-    axs[2].set_ylabel('Product')
-    if show_legend:
-        axs[2].legend(loc=legend_position)
-
-    plt.tight_layout()
-    buf = io.BytesIO()
-    plt.savefig(buf, format='png')
-    buf.seek(0)
-    image = Image.open(buf)
-
-    all_results = {
-        'biomass_models': [],
-        'substrate_models': [],
-        'product_models': []
-    }
-
-    for i, result in enumerate(biomass_results):
-        model_info = {
-            'model_number': i + 1,
-            'equation': result['equation'],
-            'parameters': result['model'].params['biomass'],
-            'R2': result['model'].r2['biomass'],
-            'RMSE': result['model'].rmse['biomass']
-        }
-        all_results['biomass_models'].append(model_info)
-
-    for i, result in enumerate(substrate_results):
-        model_info = {
-            'model_number': i + 1,
-            'equation': result['equation'],
-            'parameters': result['model'].params['substrate'],
-            'R2': result['model'].r2['substrate'],
-            'RMSE': result['model'].rmse['substrate']
-        }
-        all_results['substrate_models'].append(model_info)
-
-    for i, result in enumerate(product_results):
-        model_info = {
-            'model_number': i + 1,
-            'equation': result['equation'],
-            'parameters': result['model'].params['product'],
-            'R2': result['model'].r2['product'],
-            'RMSE': result['model'].rmse['product']
-        }
-        all_results['product_models'].append(model_info)
-
-    results_text = "Experimental Results:\n\n"
-
-    results_text += "Biomass Models:\n"
-    for model_info in all_results['biomass_models']:
-        results_text += f"""
-Model {model_info['model_number']}:
-Equation: {model_info['equation']}
-Parameters: {model_info['parameters']}
-R²: {model_info['R2']:.4f}
-RMSE: {model_info['RMSE']:.4f}
-"""
-
-    results_text += "\nSubstrate Models:\n"
-    for model_info in all_results['substrate_models']:
-        results_text += f"""
-Model {model_info['model_number']}:
-Equation: {model_info['equation']}
-Parameters: {model_info['parameters']}
-R²: {model_info['R2']:.4f}
-RMSE: {model_info['RMSE']:.4f}
-"""
-
-    results_text += "\nProduct Models:\n"
-    for model_info in all_results['product_models']:
-        results_text += f"""
-Model {model_info['model_number']}:
-Equation: {model_info['equation']}
-Parameters: {model_info['parameters']}
-R²: {model_info['R2']:.4f}
-RMSE: {model_info['RMSE']:.4f}
-"""
-
-    prompt = f"""
-You are an expert in bioprocess modeling.
-
-Analyze the following experimental results and provide a verdict on the quality of the models, suggesting improvements if necessary.
-
-{results_text}
-
-Your analysis should be detailed and professional.
-"""
-    analysis = generate_analysis(prompt)
-
-    return [image], analysis
-
-def create_interface():
-    with gr.Blocks() as demo:
-        gr.Markdown("# Bioprocess Modeling Application with Yi-Coder Integration")
-
-        file_input = gr.File(label="Upload Excel File")
-
-        MAX_EQUATIONS = 3
-        biomass_equations = []
-        biomass_params = []
-        biomass_bounds = []
-        substrate_equations = []
-        substrate_params = []
-        substrate_bounds = []
-        product_equations = []
-        product_params = []
-        product_bounds = []
-
-        def create_model_inputs(model_name, equations_list, params_list, bounds_list):
-            with gr.Column():
-                gr.Markdown(f"### {model_name} Models")
-                for i in range(MAX_EQUATIONS):
-                    with gr.Row(visible=(i == 0)) as row:
-                        equation_input = gr.Textbox(
-                            label=f"{model_name} Model {i+1} Equation",
-                            placeholder="Enter equation in terms of t and parameters",
-                            lines=1,
-                            value="" if i > 0 else "Default equation"
-                        )
-                        params_input = gr.Textbox(
-                            label=f"{model_name} Model {i+1} Parameters",
-                            placeholder="Comma-separated parameters",
-                            lines=1,
-                            value="" if i > 0 else "Parameters"
-                        )
-                        bounds_input = gr.Textbox(
-                            label=f"{model_name} Model {i+1} Bounds",
-                            placeholder="(lower, upper) for each parameter",
-                            lines=1
-                        )
-                        equations_list.append((row, equation_input))
-                        params_list.append(params_input)
-                        bounds_list.append(bounds_input)
-                add_btn = gr.Button(f"Add {model_name} Equation")
-                remove_btn = gr.Button(f"Remove {model_name} Equation")
-                return add_btn, remove_btn
-
-        with gr.Accordion("Model Definitions", open=True):
-            with gr.Row():
-                with gr.Column():
-                    add_biomass_btn, remove_biomass_btn = create_model_inputs(
-                        "Biomass", biomass_equations, biomass_params, biomass_bounds
-                    )
-                with gr.Column():
-                    add_substrate_btn, remove_substrate_btn = create_model_inputs(
-                        "Substrate", substrate_equations, substrate_params, substrate_bounds
-                    )
-                with gr.Column():
-                    add_product_btn, remove_product_btn = create_model_inputs(
-                        "Product", product_equations, product_params, product_bounds
-                    )
-
-        legend_position = gr.Radio(
-            choices=["upper left", "upper right", "lower left", "lower right", "best"],
-            label="Legend Position",
-            value="best"
-        )
-        show_legend = gr.Checkbox(label="Show Legend", value=True)
-        show_params = gr.Checkbox(label="Show Parameters", value=True)
-        simulate_btn = gr.Button("Simulate")
-
-        with gr.Row():
-            output_gallery = gr.Gallery(label="Results", columns=2, height='auto')
-            analysis_output = gr.Textbox(label="Yi-Coder Analysis", lines=15)
-
-        biomass_eq_count = gr.Number(value=1, visible=False)
-        substrate_eq_count = gr.Number(value=1, visible=False)
-        product_eq_count = gr.Number(value=1, visible=False)
-
-        def add_equation(equations_list, eq_count):
-            eq_count = min(eq_count + 1, MAX_EQUATIONS)
-            for i, (row, _) in enumerate(equations_list):
-                row.visible = i < eq_count
-            return [row.update(visible=row.visible) for row, _ in equations_list], eq_count
-
-        def remove_equation(equations_list, eq_count):
-            eq_count = max(eq_count - 1, 1)
-            for i, (row, _) in enumerate(equations_list):
-                row.visible = i < eq_count
-            return [row.update(visible=row.visible) for row, _ in equations_list], eq_count
-
-        add_biomass_btn.click(
-            fn=lambda eq_count: add_equation(biomass_equations, eq_count),
-            inputs=biomass_eq_count,
-            outputs=[*[row for row, _ in biomass_equations], biomass_eq_count]
-        )
-        remove_biomass_btn.click(
-            fn=lambda eq_count: remove_equation(biomass_equations, eq_count),
-            inputs=biomass_eq_count,
-            outputs=[*[row for row, _ in biomass_equations], biomass_eq_count]
-        )
-
-        add_substrate_btn.click(
-            fn=lambda eq_count: add_equation(substrate_equations, eq_count),
-            inputs=substrate_eq_count,
-            outputs=[*[row for row, _ in substrate_equations], substrate_eq_count]
-        )
-        remove_substrate_btn.click(
-            fn=lambda eq_count: remove_equation(substrate_equations, eq_count),
-            inputs=substrate_eq_count,
-            outputs=[*[row for row, _ in substrate_equations], substrate_eq_count]
-        )
-
-        add_product_btn.click(
-            fn=lambda eq_count: add_equation(product_equations, eq_count),
-            inputs=product_eq_count,
-            outputs=[*[row for row, _ in product_equations], product_eq_count]
-        )
-        remove_product_btn.click(
-            fn=lambda eq_count: remove_equation(product_equations, eq_count),
-            inputs=product_eq_count,
-            outputs=[*[row for row, _ in product_equations], product_eq_count]
-        )
-
-        simulate_inputs = [
-            file_input,
-            *[eq_input for row, eq_input in biomass_equations],
-            *biomass_params,
-            *biomass_bounds,
-            *[eq_input for row, eq_input in substrate_equations],
-            *substrate_params,
-            *substrate_bounds,
-            *[eq_input for row, eq_input in product_equations],
-            *product_params,
-            *product_bounds,
-            legend_position,
-            show_legend,
-            show_params,
-            biomass_eq_count,
-            substrate_eq_count,
-            product_eq_count
-        ]
-
-        simulate_btn.click(
-            fn=process_and_plot,
-            inputs=simulate_inputs,
-            outputs=[output_gallery, analysis_output]
-        )
+    # Implementación de la función process_and_plot
+    # Procesa los datos, ajusta los modelos, genera las gráficas y el análisis
+    pass  # Reemplaza con tu implementación
 
-    return demo
+# Importar la función create_interface desde UI.py
+from UI import create_interface
 
+# Si deseas ejecutar la interfaz desde este archivo, asegúrate de que este bloque no cause conflictos al importar
 if __name__ == "__main__":
     demo = create_interface()
     demo.launch()