Update app.py

app.py

@@ -33,7 +33,7 @@ os.environ['GRADIO_ANALYTICS_ENABLED'] = 'False'
 # Inicializar cliente Anthropic
 client = anthropic.Anthropic()
 
-# Sistema de traducción
+# Sistema de traducción - Actualizado con nuevas entradas
 TRANSLATIONS = {
     'en': {
         'title': '🧬 Comparative Analyzer of Biotechnological Models',
@@ -62,7 +62,9 @@ TRANSLATIONS = {
         'specialized_in': '🎯 Specialized in:',
         'metrics_analyzed': '📊 Analyzed metrics:',
         'what_analyzes': '🔍 What it specifically analyzes:',
-        'tips': '💡 Tips for better results:'
+        'tips': '💡 Tips for better results:',
+        'additional_specs': '📝 Additional specifications for analysis',
+        'additional_specs_placeholder': 'Add any specific requirements or focus areas for the analysis...'
     },
     'es': {
         'title': '🧬 Analizador Comparativo de Modelos Biotecnológicos',
@@ -91,7 +93,9 @@ TRANSLATIONS = {
         'specialized_in': '🎯 Especializado en:',
         'metrics_analyzed': '📊 Métricas analizadas:',
         'what_analyzes': '🔍 Qué analiza específicamente:',
-        'tips': '💡 Tips para mejores resultados:'
+        'tips': '💡 Tips para mejores resultados:',
+        'additional_specs': '📝 Especificaciones adicionales para el análisis',
+        'additional_specs_placeholder': 'Agregue cualquier requerimiento específico o áreas de enfoque para el análisis...'
     },
     'fr': {
         'title': '🧬 Analyseur Comparatif de Modèles Biotechnologiques',
@@ -120,7 +124,9 @@ TRANSLATIONS = {
         'specialized_in': '🎯 Spécialisé dans:',
         'metrics_analyzed': '📊 Métriques analysées:',
         'what_analyzes': '🔍 Ce qu\'il analyse spécifiquement:',
-        'tips': '💡 Conseils pour de meilleurs résultats:'
+        'tips': '💡 Conseils pour de meilleurs résultats:',
+        'additional_specs': '📝 Spécifications supplémentaires pour l\'analyse',
+        'additional_specs_placeholder': 'Ajoutez des exigences spécifiques ou des domaines d\'intérêt pour l\'analyse...'
     },
     'de': {
         'title': '🧬 Vergleichender Analysator für Biotechnologische Modelle',
@@ -149,7 +155,9 @@ TRANSLATIONS = {
         'specialized_in': '🎯 Spezialisiert auf:',
         'metrics_analyzed': '📊 Analysierte Metriken:',
         'what_analyzes': '🔍 Was spezifisch analysiert wird:',
-        'tips': '💡 Tipps für bessere Ergebnisse:'
+        'tips': '💡 Tipps für bessere Ergebnisse:',
+        'additional_specs': '📝 Zusätzliche Spezifikationen für die Analyse',
+        'additional_specs_placeholder': 'Fügen Sie spezifische Anforderungen oder Schwerpunktbereiche für die Analyse hinzu...'
     },
     'pt': {
         'title': '🧬 Analisador Comparativo de Modelos Biotecnológicos',
@@ -178,7 +186,9 @@ TRANSLATIONS = {
         'specialized_in': '🎯 Especializado em:',
         'metrics_analyzed': '📊 Métricas analisadas:',
         'what_analyzes': '🔍 O que analisa especificamente:',
-        'tips': '💡 Dicas para melhores resultados:'
+        'tips': '💡 Dicas para melhores resultados:',
+        'additional_specs': '📝 Especificações adicionais para a análise',
+        'additional_specs_placeholder': 'Adicione requisitos específicos ou áreas de foco para a análise...'
     }
 }
 
@@ -568,8 +578,9 @@ class AIAnalyzer:
         }
         return prefixes.get(language, prefixes['en'])
     
-    def analyze_fitting_results(self, data: pd.DataFrame, claude_model: str, detail_level: str = "detailed", language: str = "en") -> Dict:
-        """Analiza resultados de ajuste de modelos con soporte multiidioma"""
+    def analyze_fitting_results(self, data: pd.DataFrame, claude_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"""
         
         # Preparar resumen completo de los datos
         data_summary = f"""
@@ -592,6 +603,15 @@ class AIAnalyzer:
         # Obtener prefijo de idioma
         lang_prefix = self.get_language_prompt_prefix(language)
         
+        # Agregar especificaciones adicionales del usuario si existen
+        user_specs_section = f"""
+        
+        USER ADDITIONAL SPECIFICATIONS:
+        {additional_specs}
+        
+        Please ensure to address these specific requirements in your analysis.
+        """ if additional_specs else ""
+        
         # Prompt mejorado con instrucciones específicas para cada nivel
         if detail_level == "detailed":
             prompt = f"""
@@ -599,122 +619,143 @@ class AIAnalyzer:
             
             You are an expert in biotechnology and mathematical modeling. Analyze these kinetic/biotechnological model fitting results.
             
-            DETAIL LEVEL: DETAILED - Provide comprehensive analysis
+            {user_specs_section}
             
-            PERFORM A COMPREHENSIVE COMPARATIVE ANALYSIS:
+            DETAIL LEVEL: DETAILED - Provide comprehensive analysis BY EXPERIMENT
             
-            1. **MODEL IDENTIFICATION AND CLASSIFICATION**
-               - Identify ALL fitted mathematical models BY NAME (e.g., "Monod", "Logistic", "Gompertz", etc.)
-               - Classify them by type: biomass growth, substrate consumption, product formation
-               - Indicate the mathematical equation of each model
-               - Mention which experiments/conditions were tested
+            PERFORM A COMPREHENSIVE COMPARATIVE ANALYSIS PER EXPERIMENT:
             
-            2. **COMPARATIVE ANALYSIS OF FIT QUALITY**
-               - Compare ALL available indicators: R², RMSE, AIC, BIC, etc.
-               - Create a detailed ranking from best to worst model with exact values
-               - For the TOP 3 models, specify:
-                 * Model name: [exact name from data]
-                 * R² value: [exact value]
-                 * RMSE value: [exact value]
-                 * Key parameters and their values
-               - Identify significant differences between models
-               - Detect possible overfitting or underfitting
+            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)
             
-            3. **DETERMINATION OF THE BEST MODEL PER CATEGORY**
-               - **BEST OVERALL MODEL**: [Name] with R²=[value], RMSE=[value]
-               - **BEST BIOMASS MODEL** (if applicable): [Name] with parameters
-               - **BEST SUBSTRATE MODEL** (if applicable): [Name] with parameters  
-               - **BEST PRODUCT MODEL** (if applicable): [Name] with parameters
-               - Justify NUMERICALLY why each is the best
+            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 ANALYSIS BY VARIABLE TYPE**
-               a) **BIOMASS (if applicable)**:
-                  - Growth parameters (μmax, Xmax, etc.) with exact values
-                  - Doubling time calculations
-                  - Biomass productivity
-                  - Compare parameters between models numerically
+            4. **DETAILED COMPARATIVE TABLES**
                
-               b) **SUBSTRATE (if applicable)**:
-                  - Affinity constants (Ks, Km) with exact values
-                  - Consumption rates
-                  - Yield Yx/s calculations
-                  - Utilization efficiency percentages
+               **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       |
                
-               c) **PRODUCT (if applicable)**:
-                  - Production parameters (α, β) with exact values
-                  - Specific productivity calculations
-                  - Yield Yp/x values
-                  - Production type classification
+               **Table 2: Complete Model Comparison Across All Experiments**
+               | Model Name | Type | Exp1_R² | Exp1_RMSE | Exp2_R² | Exp2_RMSE | Avg_R² | Best_For |
             
-            5. **BIOLOGICAL INTERPRETATION OF PARAMETERS**
-               - Explain what EACH parameter means biologically
-               - Compare parameter values between models
-               - Evaluate if values are realistic for the biological system
-               - Identify critical process control parameters
+            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. **DETAILED CONCLUSIONS WITH NUMERICAL CONTENT**
-               - List the winning model for each category with full statistics
-               - Provide confidence intervals if available
-               - Indicate optimal operating conditions based on parameters
-               - Suggest specific design values for scale-up
+            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. **PRACTICAL RECOMMENDATIONS**
-               - Which specific models to use for different predictions
-               - Limitations of each selected model
-               - Recommended validation experiments
-               - Industrial implementation considerations
+            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. **COMPREHENSIVE COMPARATIVE TABLE**
-               Create a detailed table with ALL models showing:
-               | Model Name | Type | R² | RMSE | AIC | BIC | Key Parameters | Best For | Ranking |
+            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 and include ALL numerical values from the data.
+            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 of these fitting results.
+            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 essential information
+            DETAIL LEVEL: SUMMARIZED - Be concise but include all experiments and essential information
             
             PROVIDE A FOCUSED COMPARATIVE ANALYSIS:
             
-            1. **QUICK MODEL OVERVIEW**
-               - List ALL models tested: [names]
-               - Categories covered: biomass/substrate/product
+            1. **EXPERIMENTS OVERVIEW**
+               - Total experiments analyzed: [number]
+               - Conditions tested: [list]
+               - Variables measured: biomass/substrate/product
             
-            2. **BEST MODELS - TOP PERFORMERS**
-               🏆 **OVERALL WINNER**: [Model Name]
-                  - R² = [exact value]
-                  - RMSE = [exact value]
-                  - Key parameters: [list with values]
+            2. **BEST MODELS BY EXPERIMENT - QUICK SUMMARY**
+               
+               📊 **EXPERIMENT 1 [Name/Condition]:**
+               - Biomass: [Model] (R²=[value])
+               - Substrate: [Model] (R²=[value])  
+               - Product: [Model] (R²=[value])
                
-               📊 **BY CATEGORY**:
-                  - **Biomass**: [Model] (R²=[value], μmax=[value])
-                  - **Substrate**: [Model] (R²=[value], Ks=[value])
-                  - **Product**: [Model] (R²=[value], key param=[value])
+               📊 **EXPERIMENT 2 [Name/Condition]:**
+               - Biomass: [Model] (R²=[value])
+               - Substrate: [Model] (R²=[value])
+               - Product: [Model] (R²=[value])
+               
+               [Continue for all experiments...]
             
-            3. **KEY NUMERICAL FINDINGS**
-               - Best fit achieved: R² = [value] with [model]
-               - Parameter ranges: μmax=[min-max], Ks=[min-max]
-               - Productivity values: [specific numbers]
-               - Yields: Yx/s=[value], Yp/x=[value]
+            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**
-               | Rank | Model | R² | RMSE | Best Application |
-               |------|-------|-----|------|------------------|
-               | 1    | [Name]| [#] | [#]  | [Use case]      |
-               | 2    | [Name]| [#] | [#]  | [Use case]      |
-               | 3    | [Name]| [#] | [#]  | [Use case]      |
+               | 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]
             
-            5. **PRACTICAL CONCLUSIONS**
-               - Use [Model X] for biomass prediction (R²=[value])
-               - Use [Model Y] for substrate monitoring (R²=[value])
-               - Critical parameters for control: [list with values]
-               - Scale-up recommendation: [specific values]
+            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 model names and key numerical values.
+            Keep it concise but include ALL experiments and model names with their key metrics.
             """
         
         try:
@@ -737,18 +778,24 @@ class AIAnalyzer:
             Generate Python code that:
             
             1. Creates a complete analysis system with the ACTUAL NUMERICAL VALUES from the data
-            2. Implements the best models identified with their EXACT parameters
-            3. Includes visualization functions that use the REAL data values
-            4. Shows comparative analysis with the SPECIFIC numbers from the results
+            2. Implements analysis BY EXPERIMENT showing:
+               - Best models for each experiment
+               - Comparison across experiments
+               - Parameter evolution between conditions
+            3. Includes visualization functions that:
+               - Show results PER EXPERIMENT
+               - Compare models across experiments
+               - Display parameter trends
+            4. Shows the best model for biomass, substrate, and product separately
             
             The code must include:
-            - Data loading section with the actual values hardcoded as example
-            - Model implementation with the exact parameter values found
-            - Visualization showing the actual R², RMSE values in graphs
-            - Comparison functions using the real numerical data
-            - Predictions using the best model's actual parameters
+            - Data loading with experiment identification
+            - Model comparison by experiment and variable type
+            - Visualization showing results per experiment
+            - Overall best model selection with justification
+            - Functions to predict using the best models for each category
             
-            Make sure to include comments indicating which model won and why, with its exact statistics.
+            Make sure to include comments indicating which model won for each variable type and why.
             
             Format: Complete, executable Python code with actual data values embedded.
             """
@@ -780,8 +827,9 @@ class AIAnalyzer:
         except Exception as e:
             return {"error": str(e)}
 
-def process_files(files, claude_model: str, detail_level: str = "detailed", language: str = "en") -> Tuple[str, str]:
-    """Procesa múltiples archivos con soporte de idioma"""
+def process_files(files, claude_model: 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 = []
@@ -812,7 +860,9 @@ def process_files(files, claude_model: str, detail_level: str = "detailed", lang
                 analysis_type = analyzer.detect_analysis_type(df)
                 
                 if analysis_type == AnalysisType.FITTING_RESULTS:
-                    result = analyzer.analyze_fitting_results(df, claude_model, detail_level, language)
+                    result = analyzer.analyze_fitting_results(
+                        df, claude_model, detail_level, language, additional_specs
+                    )
                     
                     if language == 'es':
                         results.append("### 🎯 ANÁLISIS COMPARATIVO DE MODELOS MATEMÁTICOS")
@@ -831,7 +881,7 @@ def process_files(files, claude_model: str, detail_level: str = "detailed", lang
     return analysis_text, code_text
 
 def generate_implementation_code(analysis_results: str) -> str:
-    """Genera código de implementación con valores numéricos del análisis"""
+    """Genera código de implementación con análisis por experimento"""
     code = """
 import numpy as np
 import pandas as pd
@@ -846,16 +896,21 @@ from typing import Dict, List, Tuple, Optional
 plt.style.use('seaborn-v0_8-darkgrid')
 sns.set_palette("husl")
 
-class ComparativeModelAnalyzer:
+class ExperimentalModelAnalyzer:
     \"\"\"
-    Class for comparative analysis of biotechnological model fitting results.
-    Specialized in comparing biomass, substrate and product models.
+    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.best_models = {}
-        self.model_rankings = {}
+        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\"\"\"
@@ -870,221 +925,292 @@ class ComparativeModelAnalyzer:
         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_model_quality(self, 
+    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',
-                            aic_col: Optional[str] = 'AIC',
-                            bic_col: Optional[str] = 'BIC',
-                            model_col: str = 'Model') -> pd.DataFrame:
+                            rmse_col: str = 'RMSE') -> Dict:
         \"\"\"
-        Analyze and compare the fit quality of all models.
-        Create a ranking based on multiple metrics.
+        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()")
         
-        # Create comparison DataFrame
-        comparison = self.results_df.copy()
-        
-        # Calculate composite score
-        scores = pd.DataFrame(index=comparison.index)
-        
-        # Normalize metrics (0-1)
-        if r2_col in comparison.columns:
-            scores['r2_score'] = comparison[r2_col]  # Already between 0-1
-        
-        if rmse_col in comparison.columns:
-            # Invert and normalize RMSE (lower is better)
-            max_rmse = comparison[rmse_col].max()
-            scores['rmse_score'] = 1 - (comparison[rmse_col] / max_rmse)
-        
-        if aic_col and aic_col in comparison.columns:
-            # Invert and normalize AIC (lower is better)
-            min_aic = comparison[aic_col].min()
-            max_aic = comparison[aic_col].max()
-            scores['aic_score'] = 1 - ((comparison[aic_col] - min_aic) / (max_aic - min_aic))
-        
-        if bic_col and bic_col in comparison.columns:
-            # Invert and normalize BIC (lower is better)
-            min_bic = comparison[bic_col].min()
-            max_bic = comparison[bic_col].max()
-            scores['bic_score'] = 1 - ((comparison[bic_col] - min_bic) / (max_bic - min_bic))
-        
-        # Calculate total score (weighted average)
-        weights = {
-            'r2_score': 0.4,
-            'rmse_score': 0.3,
-            'aic_score': 0.15,
-            'bic_score': 0.15
-        }
+        results_by_exp = {}
         
-        scores['total_score'] = 0
-        for metric, weight in weights.items():
-            if metric in scores.columns:
-                scores['total_score'] += scores[metric] * weight
+        # 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'
         
-        # Add score to comparison DataFrame
-        comparison['Score'] = scores['total_score']
-        comparison['Ranking'] = comparison['Score'].rank(ascending=False).astype(int)
+        print("\\n" + "="*80)
+        print("📊 ANALYSIS BY EXPERIMENT AND VARIABLE TYPE")
+        print("="*80)
         
-        # Sort by ranking
-        comparison = comparison.sort_values('Ranking')
+        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')
+                }
         
-        # Identify best models by category
-        if 'Type' in comparison.columns:
-            for model_type in comparison['Type'].unique():
-                type_models = comparison[comparison['Type'] == model_type]
-                if not type_models.empty:
-                    best_idx = type_models['Score'].idxmax()
-                    self.best_models[model_type] = type_models.loc[best_idx]
+        self.best_models_by_experiment = results_by_exp
         
-        # Best overall model
-        best_idx = comparison['Score'].idxmax()
-        self.best_models['overall'] = comparison.loc[best_idx]
+        # Determine overall best models
+        self._determine_overall_best_models()
         
-        # Print comparison table with actual values
+        return results_by_exp
+    
+    def _determine_overall_best_models(self):
+        \"\"\"Determine the best models across all experiments\"\"\"
         print("\\n" + "="*80)
-        print("📊 MODEL COMPARISON TABLE - ACTUAL RESULTS")
+        print("🏆 OVERALL BEST MODELS ACROSS ALL EXPERIMENTS")
         print("="*80)
         
-        print(f"\\n{'Rank':<6} {'Model':<20} {'R²':<8} {'RMSE':<10} {'AIC':<10} {'BIC':<10} {'Score':<8}")
-        print("-"*80)
-        
-        for idx, row in comparison.iterrows():
-            rank = row['Ranking']
-            model = row.get(model_col, f'Model_{idx}')[:20]
-            r2 = row.get(r2_col, 0)
-            rmse = row.get(rmse_col, 0)
-            aic = row.get(aic_col, 'N/A')
-            bic = row.get(bic_col, 'N/A')
-            score = row['Score']
+        # 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"{rank:<6} {model:<20} {r2:<8.4f} {rmse:<10.4f} ", end="")
-            if isinstance(aic, (int, float)):
-                print(f"{aic:<10.2f} ", end="")
-            else:
-                print(f"{'N/A':<10} ", end="")
-            if isinstance(bic, (int, float)):
-                print(f"{bic:<10.2f} ", end="")
-            else:
-                print(f"{'N/A':<10} ", end="")
-            print(f"{score:<8.4f}")
-        
-        print("\\n🏆 BEST MODELS BY CATEGORY:")
-        for category, model_data in self.best_models.items():
-            if isinstance(model_data, pd.Series):
-                print(f"\\n{category.upper()}:")
-                print(f"  Model: {model_data.get(model_col, 'Unknown')}")
-                print(f"  R² = {model_data.get(r2_col, 0):.4f}")
-                print(f"  RMSE = {model_data.get(rmse_col, 0):.4f}")
-        
-        self.model_rankings = comparison
-        return comparison
+            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 visualize_comparison(self):
-        \"\"\"Create visualization of model comparison with actual data\"\"\"
-        if self.model_rankings is None:
-            raise ValueError("First run analyze_model_quality()")
+    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
         
-        fig, axes = plt.subplots(2, 2, figsize=(14, 10))
-        fig.suptitle('Model Comparison - Actual Fitting Results', fontsize=16)
+        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)
         
-        # 1. R² comparison
-        ax1 = axes[0, 0]
-        models = self.model_rankings.get('Model', self.model_rankings.index)
-        r2_values = self.model_rankings.get('R2', [])
-        ax1.bar(range(len(models)), r2_values, color='skyblue')
-        ax1.set_xlabel('Models')
+        ax1.set_xlabel('Experiment')
         ax1.set_ylabel('R²')
-        ax1.set_title('R² Comparison')
-        ax1.set_xticks(range(len(models)))
-        ax1.set_xticklabels(models, rotation=45, ha='right')
-        ax1.axhline(y=0.95, color='r', linestyle='--', label='Excellent fit (0.95)')
+        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 actual values on bars
-        for i, v in enumerate(r2_values):
-            ax1.text(i, v + 0.01, f'{v:.3f}', ha='center', va='bottom')
+        # 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. RMSE comparison
+        # 2. Model frequency heatmap
         ax2 = axes[0, 1]
-        rmse_values = self.model_rankings.get('RMSE', [])
-        ax2.bar(range(len(models)), rmse_values, color='salmon')
-        ax2.set_xlabel('Models')
-        ax2.set_ylabel('RMSE')
-        ax2.set_title('RMSE Comparison (Lower is Better)')
-        ax2.set_xticks(range(len(models)))
-        ax2.set_xticklabels(models, rotation=45, ha='right')
-        
-        # Add actual values on bars
-        for i, v in enumerate(rmse_values):
-            ax2.text(i, v + 0.001, f'{v:.3f}', ha='center', va='bottom')
-        
-        # 3. Combined score
+        # 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]
-        scores = self.model_rankings.get('Score', [])
-        ax3.bar(range(len(models)), scores, color='lightgreen')
-        ax3.set_xlabel('Models')
-        ax3.set_ylabel('Combined Score')
-        ax3.set_title('Overall Model Score')
-        ax3.set_xticks(range(len(models)))
-        ax3.set_xticklabels(models, rotation=45, ha='right')
-        
-        # 4. Ranking visualization
+        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]
-        rankings = self.model_rankings.get('Ranking', [])
-        ax4.scatter(r2_values, rmse_values, s=100, c=rankings, cmap='viridis')
-        ax4.set_xlabel('R²')
-        ax4.set_ylabel('RMSE')
-        ax4.set_title('R² vs RMSE (color = ranking)')
-        
-        # Annotate best model
-        best_model = self.best_models.get('overall')
-        if isinstance(best_model, pd.Series):
-            best_r2 = best_model.get('R2', 0)
-            best_rmse = best_model.get('RMSE', 0)
-            best_name = best_model.get('Model', 'Best')
-            ax4.annotate(f'Best: {best_name}', 
-                        xy=(best_r2, best_rmse),
-                        xytext=(best_r2-0.05, best_rmse+0.01),
-                        arrowprops=dict(arrowstyle='->', color='red'))
+        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 with actual data
+# Example usage
 if __name__ == "__main__":
-    print("🧬 Biotechnological Model Comparative Analysis System")
+    print("🧬 Experimental Model Comparison System")
     print("="*60)
     
-    # Example data structure (replace with your actual data)
+    # Example data structure with experiments
     example_data = {
-        'Model': ['Monod', 'Logistic', 'Gompertz', 'Modified_Gompertz'],
-        'Type': ['Substrate', 'Biomass', 'Biomass', 'Biomass'],
-        'R2': [0.9845, 0.9912, 0.9956, 0.9889],
-        'RMSE': [0.0234, 0.0189, 0.0145, 0.0201],
-        'AIC': [-45.23, -48.91, -52.34, -47.56],
-        'BIC': [-42.11, -45.79, -49.22, -44.44],
-        'mu_max': [0.45, 0.48, 0.52, 0.49],
-        'Ks': [2.1, None, None, None],
-        'Xmax': [None, 12.5, 13.1, 12.8]
+        '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 = ComparativeModelAnalyzer()
+    analyzer = ExperimentalModelAnalyzer()
     
     # Load data
     analyzer.load_results(data_dict=example_data)
     
-    # Analyze
-    results = analyzer.analyze_model_quality()
+    # Analyze by experiment
+    results = analyzer.analyze_by_experiment()
+    
+    # Create visualizations
+    analyzer.create_comparison_visualizations()
     
-    # Visualize
-    analyzer.visualize_comparison()
+    # Generate summary table
+    summary = analyzer.generate_summary_table()
     
-    print("\\n✨ Analysis complete! Best models identified with actual parameters.")
+    print("\\n✨ Analysis complete! Best models identified for each experiment and variable type.")
 """
     
     return code
@@ -1144,6 +1270,7 @@ def create_interface():
             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
@@ -1152,13 +1279,13 @@ def create_interface():
             gr.update(label=t['data_format'])    # data_format_accordion
         ]
     
-    def process_and_store(files, model, detail, language):
+    def process_and_store(files, model, detail, language, additional_specs):
         """Procesa archivos y almacena resultados"""
         if not files:
             error_msg = TRANSLATIONS[language]['error_no_files']
             return error_msg, ""
         
-        analysis, code = process_files(files, model, detail, language)
+        analysis, code = process_files(files, model, detail, language, additional_specs)
         app_state.current_analysis = analysis
         app_state.current_code = code
         return analysis, code
@@ -1210,6 +1337,15 @@ 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'],
+                    lines=3,
+                    max_lines=5,
+                    interactive=True
+                )
+                
                 analyze_btn = gr.Button(
                     TRANSLATIONS[current_language]['analyze_button'],
                     variant="primary",
@@ -1261,32 +1397,40 @@ def create_interface():
             gr.Markdown("""
             ### Expected CSV/Excel structure:
             
-            | Model | R2 | RMSE | AIC | BIC | mu_max | Ks | Parameters |
-            |-------|-----|------|-----|-----|--------|-------|------------|
-            | Monod | 0.985 | 0.023 | -45.2 | -42.1 | 0.45 | 2.1 | {...} |
-            | Logistic | 0.976 | 0.031 | -42.1 | -39.5 | 0.42 | - | {...} |
-            | Gompertz | 0.992 | 0.018 | -48.5 | -45.2 | 0.48 | - | {...} |
+            | Experiment | Model | Type | R2 | RMSE | AIC | BIC | mu_max | Ks | Parameters |
+            |------------|-------|------|-----|------|-----|-----|--------|-------|------------|
+            | 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
+            - **Model**: Model name
+            - **Type**: Variable type (Biomass/Substrate/Product)
+            - **R2, RMSE**: Fit quality metrics
+            - **Parameters**: Model-specific parameters
             """)
         
         # Definir ejemplos
         examples = gr.Examples(
             examples=[
-                [["examples/biomass_models_comparison.csv"], "claude-3-5-sonnet-20241022", "detailed"],
-                [["examples/substrate_kinetics_results.xlsx"], "claude-3-5-sonnet-20241022", "summarized"]
+                [["examples/biomass_models_comparison.csv"], "claude-3-5-sonnet-20241022", "detailed", ""],
+                [["examples/substrate_kinetics_results.xlsx"], "claude-3-5-sonnet-20241022", "summarized", "Focus on temperature effects"]
             ],
-            inputs=[files_input, model_selector, detail_level],
+            inputs=[files_input, model_selector, detail_level, additional_specs],
             label=TRANSLATIONS[current_language]['examples']
         )
         
-        # Eventos - Corregido: removiendo examples de los outputs
+        # Eventos - Actualizado para incluir additional_specs
         language_selector.change(
             update_interface_language,
             inputs=[language_selector],
             outputs=[
                 title_text, subtitle_text, files_input, model_selector,
-                language_selector, theme_selector, detail_level, analyze_btn,
-                export_format, export_btn, analysis_output, code_output,
-                data_format_accordion  # Removido examples_label
+                language_selector, theme_selector, detail_level, additional_specs,
+                analyze_btn, export_format, export_btn, analysis_output, 
+                code_output, data_format_accordion
             ]
         )
         
@@ -1304,7 +1448,7 @@ def create_interface():
         
         analyze_btn.click(
             fn=process_and_store,
-            inputs=[files_input, model_selector, detail_level, language_selector],
+            inputs=[files_input, model_selector, detail_level, language_selector, additional_specs],
             outputs=[analysis_output, code_output]
         )