Update app.py

app.py

@@ -25,6 +25,7 @@ client = anthropic.Anthropic()
 class AnalysisType(Enum):
     MATHEMATICAL_MODEL = "mathematical_model"
     DATA_FITTING = "data_fitting"
+    FITTING_RESULTS = "fitting_results"  # Nuevo: resultados de ajuste
     UNKNOWN = "unknown"
 
 # Estructura modular para modelos
@@ -36,6 +37,7 @@ class MathematicalModel:
     application: str
     sources: List[str]
     category: str
+    biological_meaning: str
 
 # Sistema de registro de modelos escalable
 class ModelRegistry:
@@ -66,7 +68,8 @@ class ModelRegistry:
             parameters=["μmax (h⁻¹)", "Ks (g/L)"],
             application="Crecimiento limitado por sustrato único",
             sources=["Cambridge", "MIT", "DTU"],
-            category="crecimiento_biomasa"
+            category="crecimiento_biomasa",
+            biological_meaning="Describe cómo la velocidad de crecimiento depende de la concentración de sustrato limitante"
         ))
         
         self.register_model(MathematicalModel(
@@ -75,7 +78,8 @@ class ModelRegistry:
             parameters=["μmax (h⁻¹)", "Xmax (g/L)"],
             application="Sistemas cerrados batch",
             sources=["Cranfield", "Swansea", "HAL Theses"],
-            category="crecimiento_biomasa"
+            category="crecimiento_biomasa",
+            biological_meaning="Modela crecimiento limitado por capacidad de carga del sistema"
         ))
         
         self.register_model(MathematicalModel(
@@ -84,7 +88,8 @@ class ModelRegistry:
             parameters=["λ (h)", "μmax (h⁻¹)", "Xmax (g/L)"],
             application="Crecimiento con fase lag pronunciada",
             sources=["Lund University", "NC State"],
-            category="crecimiento_biomasa"
+            category="crecimiento_biomasa",
+            biological_meaning="Incluye fase de adaptación (lag) seguida de crecimiento exponencial y estacionario"
         ))
         
         # Modelos enzimáticos
@@ -94,7 +99,8 @@ class ModelRegistry:
             parameters=["Vmax", "Km"],
             application="Cinética enzimática básica",
             sources=["Warsaw Univ Tech", "Food Processing"],
-            category="consumo_sustrato"
+            category="consumo_sustrato",
+            biological_meaning="Describe saturación enzimática con afinidad por sustrato"
         ))
         
         # Modelos de producto
@@ -104,7 +110,8 @@ class ModelRegistry:
             parameters=["α (asociado)", "β (no asociado)"],
             application="Producción mixta asociada/no asociada",
             sources=["Cambridge", "E-Century"],
-            category="formacion_producto"
+            category="formacion_producto",
+            biological_meaning="Separa producción ligada al crecimiento de la producción metabólica"
         ))
 
 # Instancia global del registro
@@ -187,16 +194,33 @@ class AIAnalyzer:
     def detect_analysis_type(self, content: Union[str, pd.DataFrame]) -> AnalysisType:
         """Detecta el tipo de análisis necesario"""
         if isinstance(content, pd.DataFrame):
-            # Si es DataFrame, probablemente son datos para ajustar
-            return AnalysisType.DATA_FITTING
+            # Analizar si son datos experimentales o resultados de ajuste
+            columns = [col.lower() for col in content.columns]
+            
+            # Indicadores de resultados de ajuste
+            fitting_indicators = [
+                'r2', 'r_squared', 'rmse', 'mse', 'aic', 'bic', 
+                'parameter', 'param', 'coefficient', 'fit',
+                'model', 'equation', 'goodness', 'chi_square',
+                'p_value', 'confidence', 'standard_error', 'se'
+            ]
+            
+            # Verificar si hay indicadores de resultados de ajuste
+            has_fitting_results = any(indicator in ' '.join(columns) for indicator in fitting_indicators)
+            
+            if has_fitting_results:
+                return AnalysisType.FITTING_RESULTS
+            else:
+                return AnalysisType.DATA_FITTING
         
         # Analizar texto para determinar tipo
         prompt = """
         Analiza este contenido y determina si es:
         1. Un artículo científico que describe modelos matemáticos biotecnológicos
-        2. Datos experimentales para ajuste de parámetros
+        2. Datos experimentales para ajuste de parámetros  
+        3. Resultados de ajuste de modelos (con parámetros, R², RMSE, etc.)
         
-        Responde solo con: "MODELO" o "DATOS"
+        Responde solo con: "MODELO", "DATOS" o "RESULTADOS"
         """
         
         try:
@@ -209,6 +233,8 @@ class AIAnalyzer:
             result = response.content[0].text.strip().upper()
             if "MODELO" in result:
                 return AnalysisType.MATHEMATICAL_MODEL
+            elif "RESULTADOS" in result:
+                return AnalysisType.FITTING_RESULTS
             elif "DATOS" in result:
                 return AnalysisType.DATA_FITTING
             else:
@@ -280,7 +306,7 @@ class AIAnalyzer:
             return {"error": str(e)}
     
     def analyze_fitting_data(self, data: pd.DataFrame, claude_model: str) -> Dict:
-        """Analiza datos para ajuste de parámetros"""
+        """Analiza datos experimentales para ajuste de parámetros"""
         # Preparar resumen de datos
         data_summary = f"""
         Columnas: {list(data.columns)}
@@ -314,13 +340,86 @@ class AIAnalyzer:
             )
             
             return {
-                "tipo": "Datos para Ajuste",
+                "tipo": "Datos Experimentales para Ajuste",
                 "analisis": response.content[0].text,
                 "resumen_datos": data_summary
             }
             
         except Exception as e:
             return {"error": str(e)}
+    
+    def analyze_fitting_results(self, data: pd.DataFrame, claude_model: str) -> Dict:
+        """Analiza resultados de ajuste de modelos cinéticos"""
+        # Preparar resumen detallado de resultados
+        data_summary = f"""
+        DATOS DE RESULTADOS DE AJUSTE:
+        
+        Columnas disponibles: {list(data.columns)}
+        Forma de los datos: {data.shape}
+        
+        Datos completos:
+        {data.to_string()}
+        
+        Estadísticas descriptivas:
+        {data.describe().to_string()}
+        """
+        
+        prompt = """
+        Estos son RESULTADOS DE AJUSTE DE MODELOS CINÉTICOS/BIOTECNOLÓGICOS ya calculados.
+        
+        Necesito que analices:
+        
+        1. **IDENTIFICACIÓN DE MODELOS**: ¿Qué modelos matemáticos se ajustaron? (Monod, Logístico, Gompertz, Michaelis-Menten, etc.)
+        
+        2. **CALIDAD DEL AJUSTE**: 
+           - Compara R², RMSE, AIC, BIC entre modelos
+           - ¿Cuál ajusta mejor y por qué?
+           - ¿Hay sobreajuste o subajuste?
+        
+        3. **SIGNIFICADO BIOLÓGICO**:
+           - ¿Qué significan los parámetros estimados biológicamente?
+           - ¿Son valores realistas para el sistema biológico?
+           - ¿Qué información nos dan sobre el proceso?
+        
+        4. **INFERENCIA DEL DISEÑO EXPERIMENTAL**:
+           - ¿Qué tipo de experimento se realizó?
+           - ¿Qué variables se midieron?
+           - ¿Batch, continuo, fed-batch?
+        
+        5. **INTERPRETACIÓN EN LENGUAJE HUMANO**:
+           - Traduce los resultados técnicos a conclusiones comprensibles
+           - ¿Qué nos dicen sobre el comportamiento del microorganismo/proceso?
+           - ¿Cuáles son las implicaciones prácticas?
+        
+        6. **RECOMENDACIONES**:
+           - ¿Qué modelo(s) recomiendas usar?
+           - ¿Qué limitaciones tienen?
+           - ¿Qué experimentos adicionales serían útiles?
+        
+        Estructura tu respuesta de forma clara y detallada.
+        """
+        
+        try:
+            response = self.client.messages.create(
+                model=claude_model,
+                max_tokens=4000,
+                messages=[{
+                    "role": "user",
+                    "content": f"{prompt}\n\nRESULTADOS DE AJUSTE:\n{data_summary}"
+                }]
+            )
+            
+            return {
+                "tipo": "Análisis de Resultados de Ajuste de Modelos Cinéticos",
+                "analisis_completo": response.content[0].text,
+                "resumen_datos": data_summary,
+                "n_modelos": len(data),
+                "metricas_disponibles": [col for col in data.columns if any(metric in col.lower() 
+                                       for metric in ['r2', 'rmse', 'aic', 'bic', 'mse'])]
+            }
+            
+        except Exception as e:
+            return {"error": str(e)}
 
 def process_files(files, claude_model: str) -> str:
     """Procesa múltiples archivos"""
@@ -368,7 +467,13 @@ def process_files(files, claude_model: str) -> str:
                         df = processor.read_excel(content)
                     
                     if df is not None:
-                        result = analyzer.analyze_fitting_data(df, claude_model)
+                        analysis_type = analyzer.detect_analysis_type(df)
+                        
+                        if analysis_type == AnalysisType.FITTING_RESULTS:
+                            result = analyzer.analyze_fitting_results(df, claude_model)
+                        else:
+                            result = analyzer.analyze_fitting_data(df, claude_model)
+                        
                         results.append(json.dumps(result, indent=2, ensure_ascii=False))
                 
                 results.append("\n---\n")
@@ -395,7 +500,15 @@ def process_files(files, claude_model: str) -> str:
                 df = processor.read_excel(file_content)
             
             if df is not None:
-                result = analyzer.analyze_fitting_data(df, claude_model)
+                analysis_type = analyzer.detect_analysis_type(df)
+                
+                if analysis_type == AnalysisType.FITTING_RESULTS:
+                    result = analyzer.analyze_fitting_results(df, claude_model)
+                    results.append("### 🎯 ANÁLISIS DE RESULTADOS DE AJUSTE")
+                else:
+                    result = analyzer.analyze_fitting_data(df, claude_model)
+                    results.append("### 📈 ANÁLISIS DE DATOS EXPERIMENTALES")
+                
                 results.append(json.dumps(result, indent=2, ensure_ascii=False))
         
         results.append("\n---\n")
@@ -417,138 +530,138 @@ import seaborn as sns
 plt.style.use('seaborn-v0_8-darkgrid')
 sns.set_palette("husl")
 
-class BiotechModelFitter:
-    \"\"\"Clase para ajuste de modelos biotecnológicos\"\"\"
+class BiotechModelAnalyzer:
+    \"\"\"Clase para análisis de resultados de ajuste de modelos biotecnológicos\"\"\"
     
     def __init__(self):
         self.models = {}
         self.fitted_params = {}
         self.results = {}
+        self.biological_interpretations = {}
     
-    def add_model(self, name, func, param_names):
-        \"\"\"Registra un nuevo modelo\"\"\"
-        self.models[name] = {
-            'function': func,
-            'parameters': param_names
-        }
+    def load_fitting_results(self, data_path):
+        \"\"\"Carga resultados de ajuste desde CSV/Excel\"\"\"
+        if data_path.endswith('.csv'):
+            self.results_df = pd.read_csv(data_path)
+        else:
+            self.results_df = pd.read_excel(data_path)
+        
+        return self.results_df
     
-    def fit_model(self, model_name, x_data, y_data, bounds=None):
-        \"\"\"Ajusta modelo a datos\"\"\"
-        if model_name not in self.models:
-            raise ValueError(f"Modelo {model_name} no registrado")
-        
-        model_func = self.models[model_name]['function']
-        
-        # Intentar ajuste con curve_fit
-        try:
-            if bounds:
-                popt, pcov = curve_fit(model_func, x_data, y_data, bounds=bounds)
-            else:
-                popt, pcov = curve_fit(model_func, x_data, y_data)
-            
-            # Calcular métricas
-            y_pred = model_func(x_data, *popt)
-            r2 = r2_score(y_data, y_pred)
-            rmse = np.sqrt(mean_squared_error(y_data, y_pred))
-            
-            self.fitted_params[model_name] = popt
-            self.results[model_name] = {
-                'parameters': dict(zip(self.models[model_name]['parameters'], popt)),
-                'covariance': pcov,
-                'r2': r2,
-                'rmse': rmse
-            }
+    def compare_models(self, r2_col='R2', rmse_col='RMSE', model_col='Model'):
+        \"\"\"Compara modelos basado en métricas de ajuste\"\"\"
+        if not hasattr(self, 'results_df'):
+            raise ValueError("Primero carga los datos con load_fitting_results()")
+        
+        # Ordenar por R² descendente
+        comparison = self.results_df.sort_values(by=r2_col, ascending=False)
+        
+        print("=== COMPARACIÓN DE MODELOS ===")
+        print(f"{'Modelo':<20} {'R²':<10} {'RMSE':<10} {'Ranking':<10}")
+        print("-" * 60)
+        
+        for i, (idx, row) in enumerate(comparison.iterrows()):
+            model_name = row[model_col] if model_col in row else f"Modelo_{idx}"
+            r2_val = row[r2_col] if r2_col in row else "N/A"
+            rmse_val = row[rmse_col] if rmse_col in row else "N/A"
             
-            return True
-            
-        except Exception as e:
-            print(f"Error en ajuste: {e}")
-            # Intentar con optimización global
-            return self._global_fit(model_name, x_data, y_data, bounds)
+            print(f"{model_name:<20} {r2_val:<10.4f} {rmse_val:<10.4f} {i+1:<10}")
+        
+        return comparison
     
-    def _global_fit(self, model_name, x_data, y_data, bounds):
-        \"\"\"Ajuste global con differential evolution\"\"\"
-        model_func = self.models[model_name]['function']
-        
-        def objective(params):
-            y_pred = model_func(x_data, *params)
-            return np.sum((y_data - y_pred)**2)
-        
-        if not bounds:
-            # Bounds por defecto
-            n_params = len(self.models[model_name]['parameters'])
-            bounds = [(0, 100)] * n_params
-        
-        result = differential_evolution(objective, bounds)
-        
-        if result.success:
-            popt = result.x
-            y_pred = model_func(x_data, *popt)
-            r2 = r2_score(y_data, y_pred)
-            rmse = np.sqrt(mean_squared_error(y_data, y_pred))
-            
-            self.fitted_params[model_name] = popt
-            self.results[model_name] = {
-                'parameters': dict(zip(self.models[model_name]['parameters'], popt)),
-                'r2': r2,
-                'rmse': rmse,
-                'optimization_result': result
+    def interpret_biological_meaning(self, model_name, parameters):
+        \"\"\"Interpreta el significado biológico de parámetros\"\"\"
+        interpretations = {
+            'monod': {
+                'mu_max': 'Velocidad máxima específica de crecimiento',
+                'Ks': 'Constante de saturación (afinidad por sustrato)',
+                'biological_meaning': 'Crecimiento limitado por sustrato único'
+            },
+            'logistic': {
+                'K': 'Capacidad de carga del sistema',
+                'r': 'Tasa intrínseca de crecimiento',
+                'biological_meaning': 'Crecimiento limitado por densidad poblacional'
+            },
+            'gompertz': {
+                'A': 'Asíntota superior (biomasa máxima)',
+                'mu': 'Velocidad máxima de crecimiento',
+                'lambda': 'Tiempo de fase lag',
+                'biological_meaning': 'Crecimiento con adaptación inicial'
             }
-            
-            return True
+        }
         
-        return False
+        model_key = model_name.lower()
+        if model_key in interpretations:
+            return interpretations[model_key]
+        else:
+            return {'biological_meaning': 'Modelo no reconocido en base de datos'}
     
-    def plot_results(self, x_data, y_data, models_to_plot=None):
-        \"\"\"Visualiza resultados del ajuste\"\"\"
-        plt.figure(figsize=(12, 8))
+    def generate_human_readable_report(self):
+        \"\"\"Genera reporte en lenguaje humano\"\"\"
+        if not hasattr(self, 'results_df'):
+            raise ValueError("Primero carga los datos")
+        
+        report = []
+        report.append("# 🧬 REPORTE DE ANÁLISIS BIOTECNOLÓGICO")
+        report.append("=" * 50)
+        report.append("")
+        
+        # Mejor modelo
+        best_model = self.results_df.loc[self.results_df['R2'].idxmax()]
+        report.append(f"## 🏆 MEJOR MODELO IDENTIFICADO")
+        report.append(f"**Modelo:** {best_model.get('Model', 'No especificado')}")
+        report.append(f"**Calidad del ajuste:** R² = {best_model.get('R2', 'N/A'):.4f}")
+        report.append(f"**Error:** RMSE = {best_model.get('RMSE', 'N/A'):.4f}")
+        report.append("")
+        
+        # Interpretación biológica
+        report.append("## 🔬 SIGNIFICADO BIOLÓGICO")
+        report.append("Los parámetros ajustados nos indican:")
+        
+        # Aquí puedes expandir según los modelos específicos encontrados
+        report.append("- El sistema estudiado muestra un comportamiento predecible")
+        report.append("- Los parámetros están dentro de rangos biológicamente plausibles")
+        report.append("")
+        
+        # Recomendaciones
+        report.append("## 💡 RECOMENDACIONES")
+        report.append("1. Validar el modelo con datos independientes")
+        report.append("2. Considerar factores ambientales adicionales")
+        report.append("3. Evaluar la robustez del modelo")
+        
+        return "\\n".join(report)
+    
+    def plot_model_comparison(self):
+        \"\"\"Visualiza comparación de modelos\"\"\"
+        if not hasattr(self, 'results_df'):
+            raise ValueError("Primero carga los datos")
         
-        # Datos experimentales
-        plt.scatter(x_data, y_data, label='Datos experimentales', 
-                   s=50, alpha=0.7, edgecolors='black')
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
         
-        # Modelos ajustados
-        if models_to_plot is None:
-            models_to_plot = self.fitted_params.keys()
+        # Gráfico de R²
+        models = self.results_df.get('Model', range(len(self.results_df)))
+        r2_values = self.results_df.get('R2', [])
         
-        x_smooth = np.linspace(x_data.min(), x_data.max(), 300)
+        ax1.bar(models, r2_values, color='skyblue', edgecolor='navy', alpha=0.7)
+        ax1.set_title('Comparación de R² por Modelo', fontsize=14, fontweight='bold')
+        ax1.set_ylabel('R² (Coeficiente de Determinación)', fontsize=12)
+        ax1.set_ylim(0, 1)
+        ax1.grid(True, alpha=0.3)
         
-        for model_name in models_to_plot:
-            if model_name in self.fitted_params:
-                model_func = self.models[model_name]['function']
-                params = self.fitted_params[model_name]
-                y_smooth = model_func(x_smooth, *params)
-                
-                r2 = self.results[model_name]['r2']
-                plt.plot(x_smooth, y_smooth, 
-                        label=f'{model_name} (R² = {r2:.4f})', 
-                        linewidth=2.5)
-        
-        plt.xlabel('Variable Independiente', fontsize=12)
-        plt.ylabel('Variable Dependiente', fontsize=12)
-        plt.title('Ajuste de Modelos Biotecnológicos', fontsize=14, fontweight='bold')
-        plt.legend(loc='best', frameon=True, shadow=True)
-        plt.grid(True, alpha=0.3)
-        plt.tight_layout()
+        # Rotar etiquetas si es necesario
+        plt.setp(ax1.get_xticklabels(), rotation=45, ha='right')
         
-        return plt.gcf()
-    
-    def generate_report(self):
-        \"\"\"Genera reporte de resultados\"\"\"
-        report = "# Reporte de Ajuste de Modelos\\n\\n"
+        # Gráfico de RMSE
+        rmse_values = self.results_df.get('RMSE', [])
+        ax2.bar(models, rmse_values, color='lightcoral', edgecolor='darkred', alpha=0.7)
+        ax2.set_title('Comparación de RMSE por Modelo', fontsize=14, fontweight='bold')
+        ax2.set_ylabel('RMSE (Error Cuadrático Medio)', fontsize=12)
+        ax2.grid(True, alpha=0.3)
         
-        for model_name, results in self.results.items():
-            report += f"## Modelo: {model_name}\\n\\n"
-            report += f"### Parámetros ajustados:\\n"
-            
-            for param, value in results['parameters'].items():
-                report += f"- **{param}**: {value:.6f}\\n"
-            
-            report += f"\\n### Métricas de ajuste:\\n"
-            report += f"- **R²**: {results['r2']:.6f}\\n"
-            report += f"- **RMSE**: {results['rmse']:.6f}\\n\\n"
+        plt.setp(ax2.get_xticklabels(), rotation=45, ha='right')
         
-        return report
+        plt.tight_layout()
+        return fig
 
 # Modelos predefinidos comunes
 def monod_model(S, mu_max, Ks):
@@ -563,18 +676,24 @@ def gompertz_model(t, A, mu, lambda_param):
 def michaelis_menten(S, Vmax, Km):
     return Vmax * S / (Km + S)
 
-# Ejemplo de uso
+# Ejemplo de uso para análisis de resultados
 if __name__ == "__main__":
-    # Crear instancia del ajustador
-    fitter = BiotechModelFitter()
+    # Crear instancia del analizador
+    analyzer = BiotechModelAnalyzer()
+    
+    # Ejemplo de carga de datos
+    # analyzer.load_fitting_results('resultados_ajuste.csv')
     
-    # Registrar modelos
-    fitter.add_model('Monod', monod_model, ['mu_max', 'Ks'])
-    fitter.add_model('Michaelis-Menten', michaelis_menten, ['Vmax', 'Km'])
-    fitter.add_model('Logistic', logistic_growth, ['K', 'r', 't0'])
+    # Ejemplo de comparación
+    # comparison = analyzer.compare_models()
     
-    print("Sistema de ajuste listo para usar!")
-    print("Carga tus datos y utiliza fitter.fit_model()")
+    # Generar reporte
+    # report = analyzer.generate_human_readable_report()
+    # print(report)
+    
+    print("🔬 Sistema de análisis de resultados listo!")
+    print("📊 Carga tus resultados CSV y utiliza analyzer.load_fitting_results()")
+    print("📈 Luego usa analyzer.compare_models() para comparar")
 """
     
     return code
@@ -588,31 +707,44 @@ def create_interface():
         .gradio-container {
             font-family: 'Arial', sans-serif;
         }
+        .highlight-results {
+            background-color: #f0f8ff;
+            padding: 15px;
+            border-radius: 10px;
+            border-left: 5px solid #4CAF50;
+        }
         """
     ) as demo:
         
         gr.Markdown("""
         # 🧬 Analizador Inteligente de Modelos Biotecnológicos
         
-        ### 🎯 Capacidades:
-        - **Detección automática** del tipo de documento (artículo científico vs datos experimentales)
-        - **Análisis de PDFs** con modelos matemáticos biotecnológicos
-        - **Procesamiento de datos** CSV/Excel para ajuste de parámetros
-        - **Soporte para múltiples archivos** y archivos ZIP
-        - **Generación de código** Python para implementación
+        ### 🎯 Especializado en Análisis de Resultados de Ajuste:
+        - **Análisis automático** de resultados de ajuste de modelos cinéticos
+        - **Interpretación biológica** de parámetros y métricas
+        - **Comparación inteligente** entre modelos (R², RMSE, AIC, BIC)
+        - **Traducción a lenguaje humano** de resultados técnicos
+        - **Inferencia del diseño experimental** a partir de los datos
+        - **Recomendaciones** sobre qué modelos usar y por qué
         
         ### 📁 Tipos de archivo soportados:
-        - PDF (artículos científicos o reportes de datos)
-        - CSV/Excel (datos experimentales)
-        - ZIP (múltiples archivos)
+        - **CSV/Excel** con resultados de ajuste (parámetros, R², RMSE, etc.)
+        - **PDF** con artículos científicos o reportes
+        - **ZIP** con múltiples archivos
+        
+        ### 🔍 ¿Qué analiza específicamente?
+        - Calidad del ajuste y comparación entre modelos
+        - Significado biológico de parámetros estimados
+        - Detección de sobreajuste o problemas en el ajuste
+        - Interpretación de resultados en contexto biotecnológico
         """)
         
         with gr.Row():
             with gr.Column(scale=1):
                 files_input = gr.File(
-                    label="📁 Subir archivos",
+                    label="📁 Subir resultados de ajuste (CSV/Excel)",
                     file_count="multiple",
-                    file_types=[".pdf", ".csv", ".xlsx", ".xls", ".zip"],
+                    file_types=[".csv", ".xlsx", ".xls", ".pdf", ".zip"],
                     type="filepath"
                 )
                 
@@ -624,7 +756,7 @@ def create_interface():
                 )
                 
                 analyze_btn = gr.Button(
-                    "🚀 Analizar",
+                    "🚀 Analizar Resultados",
                     variant="primary",
                     size="lg"
                 )
@@ -650,11 +782,12 @@ def create_interface():
             
             with gr.Column(scale=2):
                 analysis_output = gr.Markdown(
-                    label="📊 Resultados del Análisis"
+                    label="📊 Análisis de Resultados",
+                    elem_classes=["highlight-results"]
                 )
                 
                 code_output = gr.Code(
-                    label="💻 Código de Implementación",
+                    label="💻 Código de Análisis",
                     language="python",
                     interactive=True
                 )
@@ -662,34 +795,62 @@ def create_interface():
         # Ejemplos
         gr.Examples(
             examples=[
-                [["examples/growth_kinetics.pdf"]],
-                [["examples/experimental_data.csv"]],
-                [["examples/multiple_files.zip"]]
+                [["examples/fitting_results.csv"]],
+                [["examples/model_comparison.xlsx"]],
+                [["examples/kinetic_parameters.csv"]]
             ],
             inputs=[files_input],
-            label="📚 Ejemplos"
+            label="📚 Ejemplos de resultados de ajuste"
         )
         
+        # Guía de uso
+        gr.Markdown("""
+        ---
+        ### 📋 Guía de uso para resultados de ajuste:
+        
+        **Para obtener el mejor análisis, asegúrate que tu CSV/Excel contenga:**
+        
+        1. **Columna de modelos**: Nombres de los modelos ajustados (Monod, Logístico, Gompertz, etc.)
+        2. **Métricas de ajuste**: R², RMSE, AIC, BIC, MSE, etc.
+        3. **Parámetros**: Valores de parámetros estimados (μmax, Ks, K, etc.)
+        4. **Errores estándar**: Si están disponibles
+        
+        **Ejemplo de estructura ideal:**
+        ```
+        Model          | R2    | RMSE   | mu_max | Ks    | AIC
+        Monod          | 0.985 | 0.023  | 0.45   | 2.1   | -45.2
+        Logistic       | 0.976 | 0.031  | 0.42   | 15.3  | -42.1
+        Gompertz       | 0.992 | 0.018  | 0.48   | 1.8   | -48.5
+        ```
+        
+        ### 🔬 Lo que obtendrás:
+        - **Ranking de modelos** basado en calidad de ajuste
+        - **Interpretación biológica** de cada parámetro
+        - **Análisis del diseño experimental** inferido
+        - **Recomendaciones** sobre cuál modelo usar
+        - **Explicación en lenguaje simple** de los resultados
+        """)
+        
         # Footer
         gr.Markdown("""
         ---
         ### 🔧 Características técnicas:
-        - **Base de modelos escalable**: Fácil adición de nuevos modelos matemáticos
-        - **Análisis con IA**: Detección automática del contexto y tipo de análisis
-        - **Optimizado para HuggingFace**: Configuración lista para deployment
-        - **Código modular**: Arquitectura flexible y mantenible
-        
-        ### 📖 Instrucciones:
-        1. Sube uno o varios archivos (PDF, CSV, Excel o ZIP)
-        2. El sistema detectará automáticamente el tipo de análisis necesario
-        3. Revisa los resultados y el código generado
-        4. Copia el código para tu implementación
+        - **Detección automática** de tipo de análisis (datos vs resultados)
+        - **Interpretación contextual** de parámetros biotecnológicos
+        - **Análisis comparativo** inteligente entre modelos
+        - **Traducción técnica** a lenguaje comprensible
+        
+        ### 💡 Casos de uso:
+        - Análisis de resultados de ajustes de crecimiento microbiano
+        - Comparación de modelos de consumo de sustrato
+        - Evaluación de modelos de formación de producto
+        - Interpretación de parámetros cinéticos
         """)
         
         # Eventos
         analyze_btn.click(
             fn=lambda files, model: (
-                process_files(files, model) if files else "Por favor sube archivos para analizar",
+                process_files(files, model) if files else "Por favor sube archivos con resultados de ajuste para analizar",
                 generate_implementation_code("") if files else ""
             ),
             inputs=[files_input, model_selector],