Update app.py

app.py

@@ -1,6 +1,4 @@
 import gradio as gr
-# import anthropic  <- Eliminado
-from openai import OpenAI # <- Añadido
 import PyPDF2
 import pandas as pd
 import numpy as np
@@ -27,11 +25,12 @@ from reportlab.pdfbase import pdfmetrics
 from reportlab.pdfbase.ttfonts import TTFont
 import matplotlib.pyplot as plt
 from datetime import datetime
+from openai import OpenAI # CAMBIO: Importación de la nueva librería
 
 # Configuración para HuggingFace
 os.environ['GRADIO_ANALYTICS_ENABLED'] = 'False'
 
-# Inicializar cliente OpenAI para Nebius API
+# CAMBIO: Inicializar cliente OpenAI para Nebius
 client = OpenAI(
     base_url="https://api.studio.nebius.com/v1/",
     api_key=os.environ.get("NEBIUS_API_KEY")
@@ -43,7 +42,7 @@ TRANSLATIONS = {
         'title': '🧬 Comparative Analyzer of Biotechnological Models',
         'subtitle': 'Specialized in comparative analysis of mathematical model fitting results',
         'upload_files': '📁 Upload fitting results (CSV/Excel)',
-        'select_model': '🤖 AI Model', # Cambiado de "Claude Model"
+        'select_model': '🤖 AI Model', # CAMBIO
         'select_language': '🌐 Language',
         'select_theme': '🎨 Theme',
         'detail_level': '📋 Analysis detail level',
@@ -60,7 +59,7 @@ TRANSLATIONS = {
         'dark': 'Dark',
         'best_for': 'Best for',
         'loading': 'Loading...',
-        'error_no_api': 'Please configure NEBIUS_API_KEY in HuggingFace Space secrets', # Actualizado
+        'error_no_api': 'Please configure NEBIUS_API_KEY in HuggingFace Space secrets', # CAMBIO
         'error_no_files': 'Please upload fitting result files to analyze',
         'report_exported': 'Report exported successfully as',
         'specialized_in': '🎯 Specialized in:',
@@ -74,7 +73,7 @@ TRANSLATIONS = {
         'title': '🧬 Analizador Comparativo de Modelos Biotecnológicos',
         'subtitle': 'Especializado en análisis comparativo de resultados de ajuste de modelos matemáticos',
         'upload_files': '📁 Subir resultados de ajuste (CSV/Excel)',
-        'select_model': '🤖 Modelo de IA', # Cambiado de "Modelo Claude"
+        'select_model': '🤖 Modelo de IA', # CAMBIO
         'select_language': '🌐 Idioma',
         'select_theme': '🎨 Tema',
         'detail_level': '📋 Nivel de detalle del análisis',
@@ -91,7 +90,7 @@ TRANSLATIONS = {
         'dark': 'Oscuro',
         'best_for': 'Mejor para',
         'loading': 'Cargando...',
-        'error_no_api': 'Por favor configura NEBIUS_API_KEY en los secretos del Space', # Actualizado
+        'error_no_api': 'Por favor configura NEBIUS_API_KEY en los secretos del Space', # CAMBIO
         'error_no_files': 'Por favor sube archivos con resultados de ajuste para analizar',
         'report_exported': 'Reporte exportado exitosamente como',
         'specialized_in': '🎯 Especializado en:',
@@ -105,7 +104,7 @@ TRANSLATIONS = {
         'title': '🧬 Analyseur Comparatif de Modèles Biotechnologiques',
         'subtitle': 'Spécialisé dans l\'analyse comparative des résultats d\'ajustement',
         'upload_files': '📁 Télécharger les résultats (CSV/Excel)',
-        'select_model': '🤖 Modèle d\'IA', # Cambiado
+        'select_model': '🤖 Modèle d\'IA', # CAMBIO
         'select_language': '🌐 Langue',
         'select_theme': '🎨 Thème',
         'detail_level': '📋 Niveau de détail',
@@ -122,7 +121,7 @@ TRANSLATIONS = {
         'dark': 'Sombre',
         'best_for': 'Meilleur pour',
         'loading': 'Chargement...',
-        'error_no_api': 'Veuillez configurer NEBIUS_API_KEY', # Actualizado
+        'error_no_api': 'Veuillez configurer NEBIUS_API_KEY', # CAMBIO
         'error_no_files': 'Veuillez télécharger des fichiers à analyser',
         'report_exported': 'Rapport exporté avec succès comme',
         'specialized_in': '🎯 Spécialisé dans:',
@@ -136,7 +135,7 @@ TRANSLATIONS = {
         'title': '🧬 Vergleichender Analysator für Biotechnologische Modelle',
         'subtitle': 'Spezialisiert auf vergleichende Analyse von Modellanpassungsergebnissen',
         'upload_files': '📁 Ergebnisse hochladen (CSV/Excel)',
-        'select_model': '🤖 KI-Modell', # Cambiado
+        'select_model': '🤖 KI-Modell', # CAMBIO
         'select_language': '🌐 Sprache',
         'select_theme': '🎨 Thema',
         'detail_level': '📋 Detailgrad der Analyse',
@@ -153,7 +152,7 @@ TRANSLATIONS = {
         'dark': 'Dunkel',
         'best_for': 'Am besten für',
         'loading': 'Laden...',
-        'error_no_api': 'Bitte konfigurieren Sie NEBIUS_API_KEY', # Actualizado
+        'error_no_api': 'Bitte konfigurieren Sie NEBIUS_API_KEY', # CAMBIO
         'error_no_files': 'Bitte laden Sie Dateien zur Analyse hoch',
         'report_exported': 'Bericht erfolgreich exportiert als',
         'specialized_in': '🎯 Spezialisiert auf:',
@@ -167,7 +166,7 @@ TRANSLATIONS = {
         'title': '🧬 Analisador Comparativo de Modelos Biotecnológicos',
         'subtitle': 'Especializado em análise comparativa de resultados de ajuste',
         'upload_files': '📁 Carregar resultados (CSV/Excel)',
-        'select_model': '🤖 Modelo de IA', # Cambiado
+        'select_model': '🤖 Modelo de IA', # CAMBIO
         'select_language': '🌐 Idioma',
         'select_theme': '🎨 Tema',
         'detail_level': '📋 Nível de detalhe',
@@ -184,7 +183,7 @@ TRANSLATIONS = {
         'dark': 'Escuro',
         'best_for': 'Melhor para',
         'loading': 'Carregando...',
-        'error_no_api': 'Por favor configure NEBIUS_API_KEY', # Actualizado
+        'error_no_api': 'Por favor configure NEBIUS_API_KEY', # CAMBIO
         'error_no_files': 'Por favor carregue arquivos para analisar',
         'report_exported': 'Relatório exportado com sucesso como',
         'specialized_in': '🎯 Especializado em:',
@@ -245,21 +244,21 @@ class ModelRegistry:
     def __init__(self):
         self.models = {}
         self._initialize_default_models()
-
+    
     def register_model(self, model: MathematicalModel):
         """Registra un nuevo modelo matemático"""
         if model.category not in self.models:
             self.models[model.category] = {}
         self.models[model.category][model.name] = model
-
+    
     def get_model(self, category: str, name: str) -> MathematicalModel:
         """Obtiene un modelo específico"""
         return self.models.get(category, {}).get(name)
-
+    
     def get_all_models(self) -> Dict:
         """Retorna todos los modelos registrados"""
         return self.models
-
+    
     def _initialize_default_models(self):
         """Inicializa los modelos por defecto"""
         # Modelos de crecimiento
@@ -296,21 +295,20 @@ class ModelRegistry:
 # Instancia global del registro
 model_registry = ModelRegistry()
 
-
-# Modelos de Nebius disponibles (reemplaza a CLAUDE_MODELS)
+# CAMBIO: Modelos de Nebius en lugar de Claude
 NEBIUS_MODELS = {
     "Qwen/Qwen3-14B": {
-        "name": "Qwen 3 14B",
-        "description": "Potente modelo de Alibaba Cloud, alojado en Nebius",
-        "max_tokens": 8192,
+        "name": "Qwen 3 (14B)",
+        "description": "Modelo potente y versátil de la familia Qwen.",
+        "max_tokens": 4096,
         "best_for": "Análisis detallados y generación de código complejo."
-    }
+    },
+    # Puedes añadir más modelos de Nebius aquí si están disponibles
 }
 
-
 class FileProcessor:
     """Clase para procesar diferentes tipos de archivos"""
-
+    
     @staticmethod
     def extract_text_from_pdf(pdf_file) -> str:
         """Extrae texto de un archivo PDF"""
@@ -322,7 +320,7 @@ class FileProcessor:
             return text
         except Exception as e:
             return f"Error reading PDF: {str(e)}"
-
+    
     @staticmethod
     def read_csv(csv_file) -> pd.DataFrame:
         """Lee archivo CSV"""
@@ -330,7 +328,7 @@ class FileProcessor:
             return pd.read_csv(io.BytesIO(csv_file))
         except Exception as e:
             return None
-
+    
     @staticmethod
     def read_excel(excel_file) -> pd.DataFrame:
         """Lee archivo Excel"""
@@ -338,7 +336,7 @@ class FileProcessor:
             return pd.read_excel(io.BytesIO(excel_file))
         except Exception as e:
             return None
-
+    
     @staticmethod
     def extract_from_zip(zip_file) -> List[Tuple[str, bytes]]:
         """Extrae archivos de un ZIP"""
@@ -353,10 +351,9 @@ class FileProcessor:
             print(f"Error processing ZIP: {e}")
         return files
 
-
 class ReportExporter:
     """Clase para exportar reportes a diferentes formatos"""
-
+    
     @staticmethod
     def export_to_docx(content: str, filename: str, language: str = 'en') -> str:
         """Exporta el contenido a un archivo DOCX"""
@@ -427,7 +424,7 @@ class ReportExporter:
         # Guardar documento
         doc.save(filename)
         return filename
-
+    
     @staticmethod
     def export_to_pdf(content: str, filename: str, language: str = 'en') -> str:
         """Exporta el contenido a un archivo PDF"""
@@ -509,11 +506,11 @@ class ReportExporter:
 
 class AIAnalyzer:
     """Clase para análisis con IA"""
-
+    
     def __init__(self, client, model_registry):
         self.client = client
         self.model_registry = model_registry
-
+    
     def detect_analysis_type(self, content: Union[str, pd.DataFrame]) -> AnalysisType:
         """Detecta el tipo de análisis necesario"""
         if isinstance(content, pd.DataFrame):
@@ -543,18 +540,15 @@ class AIAnalyzer:
         """
         
         try:
-            # CAMBIO: Se usa el nuevo método de API y el nuevo modelo
+            # CAMBIO: Llamada a la API y acceso a la respuesta
             response = self.client.chat.completions.create(
-                model="Qwen/Qwen3-14B",
+                model="Qwen/Qwen3-14B", # Usar un modelo rápido disponible en Nebius
+                temperature=0.1,
                 max_tokens=10,
-                temperature=0.2, # Temperatura baja para clasificación
-                top_p=0.95,
                 messages=[{"role": "user", "content": f"{prompt}\n\n{content[:1000]}"}]
             )
             
-            # CAMBIO: Se ajusta el parseo de la respuesta
             result = response.choices[0].message.content.strip().upper()
-
             if "MODEL" in result:
                 return AnalysisType.MATHEMATICAL_MODEL
             elif "RESULTS" in result:
@@ -567,7 +561,7 @@ class AIAnalyzer:
         except Exception as e:
             print(f"Error in detect_analysis_type: {e}")
             return AnalysisType.UNKNOWN
-
+    
     def get_language_prompt_prefix(self, language: str) -> str:
         """Obtiene el prefijo del prompt según el idioma"""
         prefixes = {
@@ -578,8 +572,8 @@ class AIAnalyzer:
             'pt': "Por favor responda em português. "
         }
         return prefixes.get(language, prefixes['en'])
-
-    def analyze_fitting_results(self, data: pd.DataFrame, model_name: str, detail_level: str = "detailed", 
+    
+    def analyze_fitting_results(self, data: pd.DataFrame, nebius_model: str, detail_level: str = "detailed", 
                               language: str = "en", additional_specs: str = "") -> Dict:
         """Analiza resultados de ajuste de modelos con soporte multiidioma y especificaciones adicionales"""
         
@@ -613,45 +607,156 @@ class AIAnalyzer:
         Please ensure to address these specific requirements in your analysis.
         """ if additional_specs else ""
         
-        # Prompt mejorado con instrucciones específicas para cada nivel (sin cambios)
+        # Prompt mejorado con instrucciones específicas para cada nivel
         if detail_level == "detailed":
             prompt = f"""
             {lang_prefix}
+            
             You are an expert in biotechnology and mathematical modeling. Analyze these kinetic/biotechnological model fitting results.
+            
             {user_specs_section}
+            
             DETAIL LEVEL: DETAILED - Provide comprehensive analysis BY EXPERIMENT
+            
             PERFORM A COMPREHENSIVE COMPARATIVE ANALYSIS PER EXPERIMENT:
+            
             1. **EXPERIMENT IDENTIFICATION AND OVERVIEW**
+               - List ALL experiments/conditions tested (e.g., pH levels, temperatures, time points)
+               - For EACH experiment, identify:
+                 * Experimental conditions
+                 * Number of models tested
+                 * Variables measured (biomass, substrate, product)
+            
             2. **MODEL IDENTIFICATION AND CLASSIFICATION BY EXPERIMENT**
+               For EACH EXPERIMENT separately:
+               - Identify ALL fitted mathematical models BY NAME
+               - Classify them: biomass growth, substrate consumption, product formation
+               - Show the mathematical equation of each model
+               - List parameter values obtained for that specific experiment
+            
             3. **COMPARATIVE ANALYSIS PER EXPERIMENT**
+               Create a section for EACH EXPERIMENT showing:
+               
+               **EXPERIMENT [Name/Condition]:**
+               
+               a) **BIOMASS MODELS** (if applicable):
+                  - Best model: [Name] with R²=[value], RMSE=[value]
+                  - Parameters: μmax=[value], Xmax=[value], etc.
+                  - Ranking of all biomass models tested
+                  
+               b) **SUBSTRATE MODELS** (if applicable):
+                  - Best model: [Name] with R²=[value], RMSE=[value]
+                  - Parameters: Ks=[value], Yxs=[value], etc.
+                  - Ranking of all substrate models tested
+                  
+               c) **PRODUCT MODELS** (if applicable):
+                  - Best model: [Name] with R²=[value], RMSE=[value]
+                  - Parameters: α=[value], β=[value], etc.
+                  - Ranking of all product models tested
+            
             4. **DETAILED COMPARATIVE TABLES**
+               
+               **Table 1: Summary by Experiment and Variable Type**
+               | Experiment | Variable | Best Model | R² | RMSE | Key Parameters | Ranking |
+               |------------|----------|------------|-------|------|----------------|---------|
+               | Exp1       | Biomass  | [Name]     | [val] | [val]| μmax=X         | 1       |
+               | Exp1       | Substrate| [Name]     | [val] | [val]| Ks=Y           | 1       |
+               | Exp1       | Product  | [Name]     | [val] | [val]| α=Z            | 1       |
+               | Exp2       | Biomass  | [Name]     | [val] | [val]| μmax=X2        | 1       |
+               
+               **Table 2: Complete Model Comparison Across All Experiments**
+               | Model Name | Type | Exp1_R² | Exp1_RMSE | Exp2_R² | Exp2_RMSE | Avg_R² | Best_For |
+            
             5. **PARAMETER ANALYSIS ACROSS EXPERIMENTS**
+               - Compare how parameters change between experiments
+               - Identify trends (e.g., μmax increases with temperature)
+               - Calculate average parameters and variability
+               - Suggest optimal conditions based on parameters
+            
             6. **BIOLOGICAL INTERPRETATION BY EXPERIMENT**
+               For each experiment, explain:
+               - What the parameter values mean biologically
+               - Whether values are realistic for the conditions
+               - Key differences between experiments
+               - Critical control parameters identified
+            
             7. **OVERALL BEST MODELS DETERMINATION**
+               - **BEST BIOMASS MODEL OVERALL**: [Name] - performs best in [X] out of [Y] experiments
+               - **BEST SUBSTRATE MODEL OVERALL**: [Name] - average R²=[value]
+               - **BEST PRODUCT MODEL OVERALL**: [Name] - most consistent across conditions
+               
+               Justify with numerical evidence from multiple experiments.
+            
             8. **CONCLUSIONS AND RECOMMENDATIONS**
+               - Which models are most robust across different conditions
+               - Specific models to use for each experimental condition
+               - Confidence intervals and prediction reliability
+               - Scale-up recommendations with specific values
+            
             Use Markdown format with clear structure. Include ALL numerical values from the data.
             Create clear sections for EACH EXPERIMENT.
             """
         else:  # summarized
             prompt = f"""
             {lang_prefix}
+            
             You are an expert in biotechnology. Provide a CONCISE but COMPLETE analysis BY EXPERIMENT.
+            
             {user_specs_section}
+            
             DETAIL LEVEL: SUMMARIZED - Be concise but include all experiments and essential information
+            
             PROVIDE A FOCUSED COMPARATIVE ANALYSIS:
+            
             1. **EXPERIMENTS OVERVIEW**
+               - Total experiments analyzed: [number]
+               - Conditions tested: [list]
+               - Variables measured: biomass/substrate/product
+            
             2. **BEST MODELS BY EXPERIMENT - QUICK SUMMARY**
+               
+               📊 **EXPERIMENT 1 [Name/Condition]:**
+               - Biomass: [Model] (R²=[value])
+               - Substrate: [Model] (R²=[value])  
+               - Product: [Model] (R²=[value])
+               
+               📊 **EXPERIMENT 2 [Name/Condition]:**
+               - Biomass: [Model] (R²=[value])
+               - Substrate: [Model] (R²=[value])
+               - Product: [Model] (R²=[value])
+               
+               [Continue for all experiments...]
+            
             3. **OVERALL WINNERS ACROSS ALL EXPERIMENTS**
+               🏆 **Best Models Overall:**
+               - **Biomass**: [Model] - Best in [X]/[Y] experiments
+               - **Substrate**: [Model] - Average R²=[value]
+               - **Product**: [Model] - Most consistent performance
+            
             4. **QUICK COMPARISON TABLE**
+               | Experiment | Best Biomass | Best Substrate | Best Product | Overall R² |
+               |------------|--------------|----------------|--------------|------------|
+               | Exp1       | [Model]      | [Model]        | [Model]      | [avg]      |
+               | Exp2       | [Model]      | [Model]        | [Model]      | [avg]      |
+            
             5. **KEY FINDINGS**
+               - Parameter ranges across experiments: μmax=[min-max], Ks=[min-max]
+               - Best conditions identified: [specific values]
+               - Most robust models: [list with reasons]
+            
             6. **PRACTICAL RECOMMENDATIONS**
+               - For biomass prediction: Use [Model]
+               - For substrate monitoring: Use [Model]
+               - For product estimation: Use [Model]
+               - Critical parameters: [list with values]
+            
             Keep it concise but include ALL experiments and model names with their key metrics.
             """
         
         try:
-            # CAMBIO: Llamada a la API de Nebius
+            # CAMBIO: Llamada a la API y acceso a la respuesta
             response = self.client.chat.completions.create(
-                model=model_name,
+                model=nebius_model,
                 temperature=0.6,
                 top_p=0.95,
                 max_tokens=4000,
@@ -661,9 +766,6 @@ class AIAnalyzer:
                 }]
             )
             
-            # CAMBIO: Parseo de la respuesta
-            analysis_text = response.choices[0].message.content
-            
             # Análisis adicional para generar código con valores numéricos reales
             code_prompt = f"""
             {lang_prefix}
@@ -696,9 +798,9 @@ class AIAnalyzer:
             Format: Complete, executable Python code with actual data values embedded.
             """
             
-            # CAMBIO: Llamada a la API para generar código
+            # CAMBIO: Llamada a la API y acceso a la respuesta
             code_response = self.client.chat.completions.create(
-                model=model_name,
+                model=nebius_model,
                 temperature=0.6,
                 top_p=0.95,
                 max_tokens=3000,
@@ -708,13 +810,10 @@ class AIAnalyzer:
                 }]
             )
             
-            # CAMBIO: Parseo de la respuesta del código
-            code_text = code_response.choices[0].message.content
-            
             return {
                 "tipo": "Comparative Analysis of Mathematical Models",
-                "analisis_completo": analysis_text,
-                "codigo_implementacion": code_text,
+                "analisis_completo": response.choices[0].message.content,
+                "codigo_implementacion": code_response.choices[0].message.content,
                 "resumen_datos": {
                     "n_modelos": len(data),
                     "columnas": list(data.columns),
@@ -729,14 +828,14 @@ class AIAnalyzer:
         except Exception as e:
             return {"error": str(e)}
 
-def process_files(files, model_name: str, detail_level: str = "detailed",
-                  language: str = "en", additional_specs: str = "") -> Tuple[str, str]:
+def process_files(files, model_name: str, detail_level: str = "detailed", 
+                 language: str = "en", additional_specs: str = "") -> Tuple[str, str]:
     """Procesa múltiples archivos con soporte de idioma y especificaciones adicionales"""
     processor = FileProcessor()
     analyzer = AIAnalyzer(client, model_registry)
     results = []
     all_code = []
-
+    
     for file in files:
         if file is None:
             continue
@@ -776,19 +875,346 @@ def process_files(files, model_name: str, detail_level: str = "detailed",
                         all_code.append(result["codigo_implementacion"])
         
         results.append("\n---\n")
-
+    
     analysis_text = "\n".join(results)
     code_text = "\n\n# " + "="*50 + "\n\n".join(all_code) if all_code else generate_implementation_code(analysis_text)
-
+    
     return analysis_text, code_text
 
 def generate_implementation_code(analysis_results: str) -> str:
-    """Genera código de implementación con análisis por experimento (función de respaldo)"""
-    # Esta función no necesita cambios, ya que no hace llamadas a la API
-    # ... (el código de esta función permanece igual) ...
-    # Se omite por brevedad, el código original es correcto.
-    return "" # Devuelve un string vacío o un esqueleto básico si se necesita.
+    """Genera código de implementación con análisis por experimento"""
+    code = """
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy.integrate import odeint
+from scipy.optimize import curve_fit, differential_evolution
+from sklearn.metrics import r2_score, mean_squared_error
+import seaborn as sns
+from typing import Dict, List, Tuple, Optional
+
+# Visualization configuration
+plt.style.use('seaborn-v0_8-darkgrid')
+sns.set_palette("husl")
+
+class ExperimentalModelAnalyzer:
+    \"\"\"
+    Class for comparative analysis of biotechnological models across multiple experiments.
+    Analyzes biomass, substrate and product models separately for each experimental condition.
+    \"\"\"
+    
+    def __init__(self):
+        self.results_df = None
+        self.experiments = {}
+        self.best_models_by_experiment = {}
+        self.overall_best_models = {
+            'biomass': None,
+            'substrate': None,
+            'product': None
+        }
+        
+    def load_results(self, file_path: str = None, data_dict: dict = None) -> pd.DataFrame:
+        \"\"\"Load fitting results from CSV/Excel file or dictionary\"\"\"
+        if data_dict:
+            self.results_df = pd.DataFrame(data_dict)
+        elif file_path:
+            if file_path.endswith('.csv'):
+                self.results_df = pd.read_csv(file_path)
+            else:
+                self.results_df = pd.read_excel(file_path)
+        
+        print(f"✅ Data loaded: {len(self.results_df)} models")
+        print(f"📊 Available columns: {list(self.results_df.columns)}")
+        
+        # Identify experiments
+        if 'Experiment' in self.results_df.columns:
+            self.experiments = self.results_df.groupby('Experiment').groups
+            print(f"🧪 Experiments found: {list(self.experiments.keys())}")
+        
+        return self.results_df
+    
+    def analyze_by_experiment(self, 
+                            experiment_col: str = 'Experiment',
+                            model_col: str = 'Model',
+                            type_col: str = 'Type',
+                            r2_col: str = 'R2',
+                            rmse_col: str = 'RMSE') -> Dict:
+        \"\"\"
+        Analyze models by experiment and variable type.
+        Identifies best models for biomass, substrate, and product in each experiment.
+        \"\"\"
+        if self.results_df is None:
+            raise ValueError("First load data with load_results()")
+        
+        results_by_exp = {}
+        
+        # Get unique experiments
+        if experiment_col in self.results_df.columns:
+            experiments = self.results_df[experiment_col].unique()
+        else:
+            experiments = ['All_Data']
+            self.results_df[experiment_col] = 'All_Data'
+        
+        print("\\n" + "="*80)
+        print("📊 ANALYSIS BY EXPERIMENT AND VARIABLE TYPE")
+        print("="*80)
+        
+        for exp in experiments:
+            print(f"\\n🧪 EXPERIMENT: {exp}")
+            print("-"*50)
+            
+            exp_data = self.results_df[self.results_df[experiment_col] == exp]
+            results_by_exp[exp] = {}
+            
+            # Analyze by variable type if available
+            if type_col in exp_data.columns:
+                var_types = exp_data[type_col].unique()
+                
+                for var_type in var_types:
+                    var_data = exp_data[exp_data[type_col] == var_type]
+                    
+                    if not var_data.empty:
+                        # Find best model for this variable type
+                        best_idx = var_data[r2_col].idxmax()
+                        best_model = var_data.loc[best_idx]
+                        
+                        results_by_exp[exp][var_type] = {
+                            'best_model': best_model[model_col],
+                            'r2': best_model[r2_col],
+                            'rmse': best_model[rmse_col],
+                            'all_models': var_data[[model_col, r2_col, rmse_col]].to_dict('records')
+                        }
+                        
+                        print(f"\\n  📈 {var_type.upper()}:")
+                        print(f"    Best Model: {best_model[model_col]}")
+                        print(f"    R² = {best_model[r2_col]:.4f}")
+                        print(f"    RMSE = {best_model[rmse_col]:.4f}")
+                        
+                        # Show all models for this variable
+                        print(f"\\n    All {var_type} models tested:")
+                        for _, row in var_data.iterrows():
+                            print(f"      - {row[model_col]}: R²={row[r2_col]:.4f}, RMSE={row[rmse_col]:.4f}")
+            else:
+                # If no type column, analyze all models together
+                best_idx = exp_data[r2_col].idxmax()
+                best_model = exp_data.loc[best_idx]
+                
+                results_by_exp[exp]['all'] = {
+                    'best_model': best_model[model_col],
+                    'r2': best_model[r2_col],
+                    'rmse': best_model[rmse_col],
+                    'all_models': exp_data[[model_col, r2_col, rmse_col]].to_dict('records')
+                }
+        
+        self.best_models_by_experiment = results_by_exp
+        
+        # Determine overall best models
+        self._determine_overall_best_models()
+        
+        return results_by_exp
+    
+    def _determine_overall_best_models(self):
+        \"\"\"Determine the best models across all experiments\"\"\"
+        print("\\n" + "="*80)
+        print("🏆 OVERALL BEST MODELS ACROSS ALL EXPERIMENTS")
+        print("="*80)
+        
+        # Aggregate performance by model and type
+        model_performance = {}
+        
+        for exp, exp_results in self.best_models_by_experiment.items():
+            for var_type, var_results in exp_results.items():
+                if var_type not in model_performance:
+                    model_performance[var_type] = {}
+                
+                for model_data in var_results['all_models']:
+                    model_name = model_data['Model']
+                    if model_name not in model_performance[var_type]:
+                        model_performance[var_type][model_name] = {
+                            'r2_values': [],
+                            'rmse_values': [],
+                            'experiments': []
+                        }
+                    
+                    model_performance[var_type][model_name]['r2_values'].append(model_data['R2'])
+                    model_performance[var_type][model_name]['rmse_values'].append(model_data['RMSE'])
+                    model_performance[var_type][model_name]['experiments'].append(exp)
+        
+        # Calculate average performance and select best
+        for var_type, models in model_performance.items():
+            best_avg_r2 = -1
+            best_model = None
+            
+            print(f"\\n📊 {var_type.upper()} MODELS:")
+            for model_name, perf_data in models.items():
+                avg_r2 = np.mean(perf_data['r2_values'])
+                avg_rmse = np.mean(perf_data['rmse_values'])
+                n_exp = len(perf_data['experiments'])
+                
+                print(f"  {model_name}:")
+                print(f"    Average R² = {avg_r2:.4f}")
+                print(f"    Average RMSE = {avg_rmse:.4f}")
+                print(f"    Tested in {n_exp} experiments")
+                
+                if avg_r2 > best_avg_r2:
+                    best_avg_r2 = avg_r2
+                    best_model = {
+                        'name': model_name,
+                        'avg_r2': avg_r2,
+                        'avg_rmse': avg_rmse,
+                        'n_experiments': n_exp
+                    }
+            
+            if var_type.lower() in ['biomass', 'substrate', 'product']:
+                self.overall_best_models[var_type.lower()] = best_model
+                print(f"\\n  🏆 BEST {var_type.upper()} MODEL: {best_model['name']} (Avg R²={best_model['avg_r2']:.4f})")
+    
+    def create_comparison_visualizations(self):
+        \"\"\"Create visualizations comparing models across experiments\"\"\"
+        if not self.best_models_by_experiment:
+            raise ValueError("First run analyze_by_experiment()")
+        
+        # Prepare data for visualization
+        experiments = []
+        biomass_r2 = []
+        substrate_r2 = []
+        product_r2 = []
+        
+        for exp, results in self.best_models_by_experiment.items():
+            experiments.append(exp)
+            biomass_r2.append(results.get('Biomass', {}).get('r2', 0))
+            substrate_r2.append(results.get('Substrate', {}).get('r2', 0))
+            product_r2.append(results.get('Product', {}).get('r2', 0))
+        
+        # Create figure with subplots
+        fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+        fig.suptitle('Model Performance Comparison Across Experiments', fontsize=16)
+        
+        # 1. R² comparison by experiment and variable type
+        ax1 = axes[0, 0]
+        x = np.arange(len(experiments))
+        width = 0.25
+        
+        ax1.bar(x - width, biomass_r2, width, label='Biomass', color='green', alpha=0.8)
+        ax1.bar(x, substrate_r2, width, label='Substrate', color='blue', alpha=0.8)
+        ax1.bar(x + width, product_r2, width, label='Product', color='red', alpha=0.8)
+        
+        ax1.set_xlabel('Experiment')
+        ax1.set_ylabel('R²')
+        ax1.set_title('Best Model R² by Experiment and Variable Type')
+        ax1.set_xticks(x)
+        ax1.set_xticklabels(experiments, rotation=45, ha='right')
+        ax1.legend()
+        ax1.grid(True, alpha=0.3)
+        
+        # Add value labels
+        for i, (b, s, p) in enumerate(zip(biomass_r2, substrate_r2, product_r2)):
+            if b > 0: ax1.text(i - width, b + 0.01, f'{b:.3f}', ha='center', va='bottom', fontsize=8)
+            if s > 0: ax1.text(i, s + 0.01, f'{s:.3f}', ha='center', va='bottom', fontsize=8)
+            if p > 0: ax1.text(i + width, p + 0.01, f'{p:.3f}', ha='center', va='bottom', fontsize=8)
+        
+        # 2. Model frequency heatmap
+        ax2 = axes[0, 1]
+        # This would show which models appear most frequently as best
+        # Implementation depends on actual data structure
+        ax2.text(0.5, 0.5, 'Model Frequency Analysis\\n(Most Used Models)', 
+                ha='center', va='center', transform=ax2.transAxes)
+        ax2.set_title('Most Frequently Selected Models')
+        
+        # 3. Parameter evolution across experiments
+        ax3 = axes[1, 0]
+        ax3.text(0.5, 0.5, 'Parameter Evolution\\nAcross Experiments', 
+                ha='center', va='center', transform=ax3.transAxes)
+        ax3.set_title('Parameter Trends')
+        
+        # 4. Overall best models summary
+        ax4 = axes[1, 1]
+        ax4.axis('off')
+        
+        summary_text = "🏆 OVERALL BEST MODELS\\n\\n"
+        for var_type, model_info in self.overall_best_models.items():
+            if model_info:
+                summary_text += f"{var_type.upper()}:\\n"
+                summary_text += f"  Model: {model_info['name']}\\n"
+                summary_text += f"  Avg R²: {model_info['avg_r2']:.4f}\\n"
+                summary_text += f"  Tested in: {model_info['n_experiments']} experiments\\n\\n"
+        
+        ax4.text(0.1, 0.9, summary_text, transform=ax4.transAxes, 
+                fontsize=12, verticalalignment='top', fontfamily='monospace')
+        ax4.set_title('Overall Best Models Summary')
+        
+        plt.tight_layout()
+        plt.show()
+    
+    def generate_summary_table(self) -> pd.DataFrame:
+        \"\"\"Generate a summary table of best models by experiment and type\"\"\"
+        summary_data = []
+        
+        for exp, results in self.best_models_by_experiment.items():
+            for var_type, var_results in results.items():
+                summary_data.append({
+                    'Experiment': exp,
+                    'Variable_Type': var_type,
+                    'Best_Model': var_results['best_model'],
+                    'R2': var_results['r2'],
+                    'RMSE': var_results['rmse']
+                })
+        
+        summary_df = pd.DataFrame(summary_data)
+        
+        print("\\n📋 SUMMARY TABLE: BEST MODELS BY EXPERIMENT AND VARIABLE TYPE")
+        print("="*80)
+        print(summary_df.to_string(index=False))
+        
+        return summary_df
 
+# Example usage
+if __name__ == "__main__":
+    print("🧬 Experimental Model Comparison System")
+    print("="*60)
+    
+    # Example data structure with experiments
+    example_data = {
+        'Experiment': ['pH_7.0', 'pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5', 'pH_7.5',
+                      'pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5',
+                      'pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5'],
+        'Model': ['Monod', 'Logistic', 'Gompertz', 'Monod', 'Logistic', 'Gompertz',
+                 'First_Order', 'Monod_Substrate', 'First_Order', 'Monod_Substrate',
+                 'Luedeking_Piret', 'Linear', 'Luedeking_Piret', 'Linear'],
+        'Type': ['Biomass', 'Biomass', 'Biomass', 'Biomass', 'Biomass', 'Biomass',
+                'Substrate', 'Substrate', 'Substrate', 'Substrate',
+                'Product', 'Product', 'Product', 'Product'],
+        'R2': [0.9845, 0.9912, 0.9956, 0.9789, 0.9834, 0.9901,
+              0.9723, 0.9856, 0.9698, 0.9812,
+              0.9634, 0.9512, 0.9687, 0.9423],
+        'RMSE': [0.0234, 0.0189, 0.0145, 0.0267, 0.0223, 0.0178,
+                0.0312, 0.0245, 0.0334, 0.0289,
+                0.0412, 0.0523, 0.0389, 0.0567],
+        'mu_max': [0.45, 0.48, 0.52, 0.42, 0.44, 0.49,
+                  None, None, None, None, None, None, None, None],
+        'Ks': [None, None, None, None, None, None,
+              2.1, 1.8, 2.3, 1.9, None, None, None, None]
+    }
+    
+    # Create analyzer
+    analyzer = ExperimentalModelAnalyzer()
+    
+    # Load data
+    analyzer.load_results(data_dict=example_data)
+    
+    # Analyze by experiment
+    results = analyzer.analyze_by_experiment()
+    
+    # Create visualizations
+    analyzer.create_comparison_visualizations()
+    
+    # Generate summary table
+    summary = analyzer.generate_summary_table()
+    
+    print("\\n✨ Analysis complete! Best models identified for each experiment and variable type.")
+"""
+    
+    return code
 
 # Estado global para almacenar resultados
 class AppState:
@@ -810,9 +1236,9 @@ def export_report(export_format: str, language: str) -> Tuple[str, str]:
             'pt': "Nenhuma análise disponível para exportar"
         }
         return error_msg.get(language, error_msg['en']), ""
-
+    
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-
+    
     try:
         if export_format == "DOCX":
             filename = f"biotech_analysis_report_{timestamp}.docx"
@@ -831,29 +1257,29 @@ def create_interface():
     # Estado inicial
     current_theme = "light"
     current_language = "en"
-
+    
     def update_interface_language(language):
         """Actualiza el idioma de la interfaz"""
         app_state.current_language = language
         t = TRANSLATIONS[language]
         
         return [
-            gr.update(value=f"# {t['title']}"),
-            gr.update(value=t['subtitle']),
-            gr.update(label=t['upload_files']),
-            gr.update(label=t['select_model']),
-            gr.update(label=t['select_language']),
-            gr.update(label=t['select_theme']),
-            gr.update(label=t['detail_level']),
-            gr.update(label=t['additional_specs'], placeholder=t['additional_specs_placeholder']),
-            gr.update(value=t['analyze_button']),
-            gr.update(label=t['export_format']),
-            gr.update(value=t['export_button']),
-            gr.update(label=t['comparative_analysis']),
-            gr.update(label=t['implementation_code']),
-            gr.update(label=t['data_format'])
+            gr.update(value=f"# {t['title']}"),  # title_text
+            gr.update(value=t['subtitle']),       # subtitle_text
+            gr.update(label=t['upload_files']),   # files_input
+            gr.update(label=t['select_model']),   # model_selector
+            gr.update(label=t['select_language']), # language_selector
+            gr.update(label=t['select_theme']),   # theme_selector
+            gr.update(label=t['detail_level']),   # detail_level
+            gr.update(label=t['additional_specs'], placeholder=t['additional_specs_placeholder']), # additional_specs
+            gr.update(value=t['analyze_button']), # analyze_btn
+            gr.update(label=t['export_format']),  # export_format
+            gr.update(value=t['export_button']),  # export_btn
+            gr.update(label=t['comparative_analysis']), # analysis_output
+            gr.update(label=t['implementation_code']),  # code_output
+            gr.update(label=t['data_format'])    # data_format_accordion
         ]
-
+    
     def process_and_store(files, model, detail, language, additional_specs):
         """Procesa archivos y almacena resultados"""
         if not files:
@@ -864,8 +1290,9 @@ def create_interface():
         app_state.current_analysis = analysis
         app_state.current_code = code
         return analysis, code
-
+    
     with gr.Blocks(theme=THEMES[current_theme]) as demo:
+        # Componentes de UI
         with gr.Row():
             with gr.Column(scale=3):
                 title_text = gr.Markdown(f"# {TRANSLATIONS[current_language]['title']}")
@@ -895,12 +1322,13 @@ def create_interface():
                     type="filepath"
                 )
                 
-                # CAMBIO: Selector de modelo actualizado a Nebius
+                # CAMBIO: Usar el diccionario de modelos de Nebius
+                default_model = "Qwen/Qwen3-14B"
                 model_selector = gr.Dropdown(
                     choices=list(NEBIUS_MODELS.keys()),
-                    value="Qwen/Qwen3-14B",
+                    value=default_model,
                     label=TRANSLATIONS[current_language]['select_model'],
-                    info=f"{TRANSLATIONS[current_language]['best_for']}: {NEBIUS_MODELS['Qwen/Qwen3-14B']['best_for']}"
+                    info=f"{TRANSLATIONS[current_language]['best_for']}: {NEBIUS_MODELS[default_model]['best_for']}"
                 )
                 
                 detail_level = gr.Radio(
@@ -912,6 +1340,7 @@ def create_interface():
                     label=TRANSLATIONS[current_language]['detail_level']
                 )
                 
+                # Nueva entrada para especificaciones adicionales
                 additional_specs = gr.Textbox(
                     label=TRANSLATIONS[current_language]['additional_specs'],
                     placeholder=TRANSLATIONS[current_language]['additional_specs_placeholder'],
@@ -975,6 +1404,8 @@ def create_interface():
             |------------|-------|------|-----|------|-----|-----|--------|-------|------------|
             | pH_7.0 | Monod | Biomass | 0.985 | 0.023 | -45.2 | -42.1 | 0.45 | 2.1 | {...} |
             | pH_7.0 | Logistic | Biomass | 0.976 | 0.031 | -42.1 | -39.5 | 0.42 | - | {...} |
+            | pH_7.0 | First_Order | Substrate | 0.992 | 0.018 | -48.5 | -45.2 | - | 1.8 | {...} |
+            | pH_7.5 | Monod | Biomass | 0.978 | 0.027 | -44.1 | -41.2 | 0.43 | 2.2 | {...} |
             
             **Important columns:**
             - **Experiment**: Experimental condition identifier
@@ -984,7 +1415,7 @@ def create_interface():
             - **Parameters**: Model-specific parameters
             """)
         
-        # CAMBIO: Ejemplos actualizados para usar el nuevo modelo
+        # CAMBIO: Actualizar el modelo en los ejemplos
         examples = gr.Examples(
             examples=[
                 [["examples/biomass_models_comparison.csv"], "Qwen/Qwen3-14B", "detailed", ""],
@@ -994,6 +1425,7 @@ def create_interface():
             label=TRANSLATIONS[current_language]['examples']
         )
         
+        # Eventos
         language_selector.change(
             update_interface_language,
             inputs=[language_selector],
@@ -1006,6 +1438,7 @@ def create_interface():
         )
         
         def change_theme(theme_name):
+            """Cambia el tema de la interfaz"""
             return gr.Info("Theme will be applied on next page load")
         
         theme_selector.change(
@@ -1032,34 +1465,49 @@ def create_interface():
             inputs=[export_format, language_selector],
             outputs=[export_status, export_file]
         )
-
+    
     return demo
 
 # Función principal
 def main():
-    # CAMBIO: Verificación de la nueva clave API
+    # CAMBIO: Comprobar la nueva variable de entorno
     if not os.getenv("NEBIUS_API_KEY"):
         print("⚠️ Configure NEBIUS_API_KEY in HuggingFace Space secrets")
-        # Actualizar el mensaje de error en la UI
-        error_msg = TRANSLATIONS['en']['error_no_api']
         return gr.Interface(
-            fn=lambda x: error_msg,
+            fn=lambda x: TRANSLATIONS['en']['error_no_api'],
             inputs=gr.Textbox(),
             outputs=gr.Textbox(),
             title="Configuration Error"
         )
-
+    
     return create_interface()
 
 # Para ejecución local
 if __name__ == "__main__":
-    # He eliminado el código de ejemplo de `__main__` que estaba fuera de la función
-    # `generate_implementation_code` para mayor claridad y evitar que se ejecute al importar.
-    # El punto de entrada principal es la interfaz de Gradio.
     demo = main()
     if demo:
+        # Para crear los archivos de ejemplo si no existen
+        if not os.path.exists("examples"):
+            os.makedirs("examples")
+        if not os.path.exists("examples/biomass_models_comparison.csv"):
+            pd.DataFrame({
+                'Experiment': ['pH_7.0', 'pH_7.0', 'pH_7.0', 'pH_7.5', 'pH_7.5', 'pH_7.5'],
+                'Model': ['Monod', 'Logistic', 'Gompertz', 'Monod', 'Logistic', 'Gompertz'],
+                'Type': ['Biomass', 'Biomass', 'Biomass', 'Biomass', 'Biomass', 'Biomass'],
+                'R2': [0.98, 0.99, 0.995, 0.97, 0.98, 0.99],
+                'RMSE': [0.02, 0.01, 0.005, 0.03, 0.02, 0.01]
+            }).to_csv("examples/biomass_models_comparison.csv", index=False)
+        if not os.path.exists("examples/substrate_kinetics_results.xlsx"):
+             pd.DataFrame({
+                'Experiment': ['Temp_30C', 'Temp_30C', 'Temp_37C', 'Temp_37C'],
+                'Model': ['First_Order', 'Monod_Substrate', 'First_Order', 'Monod_Substrate'],
+                'Type': ['Substrate', 'Substrate', 'Substrate', 'Substrate'],
+                'R2': [0.97, 0.98, 0.96, 0.985],
+                'RMSE': [0.03, 0.02, 0.04, 0.015]
+            }).to_excel("examples/substrate_kinetics_results.xlsx", index=False)
+
         demo.launch(
             server_name="0.0.0.0",
             server_port=7860,
-            share=os.getenv("GRADIO_SHARE", "false").lower() == "true"
+            share=False
         )