Update interface.py

interface.py

@@ -1,6 +1,6 @@
 # interface.py
 
-from UI import create_interface
+import gradio as gr
 from models import BioprocessModel
 import io
 from PIL import Image
@@ -9,6 +9,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM
+from sympy import symbols, sympify, lambdify
 import copy
 from config import DEVICE, MODEL_PATH, MAX_LENGTH, TEMPERATURE
 
@@ -49,15 +50,15 @@ def parse_bounds(bounds_str, num_params):
 
 def process_and_plot(
     file,
-    biomass_equations_list,
-    biomass_params_list,
-    biomass_bounds_list,
-    substrate_equations_list,
-    substrate_params_list,
-    substrate_bounds_list,
-    product_equations_list,
-    product_params_list,
-    product_bounds_list,
+    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,
@@ -65,10 +66,385 @@ def process_and_plot(
     substrate_eq_count,
     product_eq_count
 ):
-    # Implement the function to process data, fit models, generate plots, and get analysis
-    # Return the plot image and analysis
+    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]
+        )
+
+    return demo
+
 if __name__ == "__main__":
-    demo = create_interface(process_and_plot)
+    demo = create_interface()
     demo.launch()