Update app.py

app.py

@@ -1,5 +1,6 @@
 import warnings
 import time
+import os
 from typing import Dict, Tuple, List
 from dataclasses import dataclass
 
@@ -226,10 +227,32 @@ class BenchmarkEvaluator:
             EvaluationConfig(api_key=gemini_api_key)
         )
         self.stability_evaluator = StabilityEvaluator()
+        self.results_history = []
         
-    def evaluate_model(self, df, model_name, prompt_col='rus_prompt'):
+        # Create results directory if it doesn't exist
+        os.makedirs('results', exist_ok=True)
+        
+        # Load previous benchmark results if available
+        self.benchmark_file = 'results/benchmark_results.csv'
+        if os.path.exists(self.benchmark_file):
+            try:
+                self.leaderboard_df = pd.read_csv(self.benchmark_file)
+            except:
+                self.leaderboard_df = pd.DataFrame(columns=[
+                    'model', 'creativity_score', 'stability_score', 
+                    'combined_score', 'evaluation_timestamp'
+                ])
+        else:
+            self.leaderboard_df = pd.DataFrame(columns=[
+                'model', 'creativity_score', 'stability_score', 
+                'combined_score', 'evaluation_timestamp'
+            ])
+        
+    def evaluate_model(self, df, model_name, prompt_col='rus_prompt', answer_col=None):
         """Evaluate a single model's responses"""
-        answer_col = f"{model_name}_answers"
+        # Use direct answer column if provided, otherwise derive from model name
+        if answer_col is None:
+            answer_col = f"{model_name}_answers"
         
         if answer_col not in df.columns:
             raise ValueError(f"Column {answer_col} not found in dataframe")
@@ -247,11 +270,15 @@ class BenchmarkEvaluator:
         stability_score = stability_results['stability_score']
         combined_score = (creative_score + stability_score) / 2
         
+        # Add timestamp
+        timestamp = pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S')
+        
         results = {
             'model': model_name,
             'creativity_score': creative_score,
             'stability_score': stability_score,
             'combined_score': combined_score,
+            'evaluation_timestamp': timestamp,
             'creative_details': {
                 'creativity': creative_df["Креативность"].mean(),
                 'diversity': creative_df["Разнообразие"].mean(),
@@ -261,36 +288,96 @@ class BenchmarkEvaluator:
         }
         
         # Save detailed results
-        output_file = f'evaluated_responses_{model_name}.csv'
+        output_file = f'results/evaluated_responses_{model_name}_{timestamp.replace(":", "-").replace(" ", "_")}.csv'
         creative_df.to_csv(output_file, index=False)
         print(f"Detailed results saved to {output_file}")
         
-        return results
-    
-    def evaluate_all_models(self, df, models=None, prompt_col='rus_prompt'):
-        """Evaluate multiple models from the dataframe"""
-        if models is None:
-            # Find all columns ending with _answers
-            answer_cols = [col for col in df.columns if col.endswith('_answers')]
-            models = [col.replace('_answers', '') for col in answer_cols]
-        
-        results = []
-        for model in models:
-            try:
-                model_results = self.evaluate_model(df, model, prompt_col)
-                results.append(model_results)
-                print(f"Completed evaluation for {model}")
-            except Exception as e:
-                print(f"Error evaluating {model}: {str(e)}")
-        
-        benchmark_df = pd.DataFrame(results)
-        benchmark_df.to_csv('benchmark_results.csv', index=False)
-        print("Benchmark completed. Results saved to benchmark_results.csv")
+        # Update leaderboard
+        result_row = {
+            'model': model_name,
+            'creativity_score': creative_score,
+            'stability_score': stability_score,
+            'combined_score': combined_score,
+            'evaluation_timestamp': timestamp
+        }
+        self.leaderboard_df = pd.concat([self.leaderboard_df, pd.DataFrame([result_row])], ignore_index=True)
+        self.leaderboard_df.to_csv(self.benchmark_file, index=False)
         
-        return benchmark_df
+        self.results_history.append(results)
+        return results, creative_df
+    
+def evaluate_all_models(self, df, models=None, model_columns=None, prompt_col='rus_prompt'):
+    """Evaluate multiple models from the dataframe"""
+    if models is not None and model_columns is not None:
+        model_mapping = dict(zip(models, model_columns))
+    elif models is not None:
+        model_mapping = {model: f"{model}_answers" for model in models}
+    else:
+        answer_cols = [col for col in df.columns if col.endswith('_answers')]
+        models = [col.replace('_answers', '') for col in answer_cols]
+        model_mapping = dict(zip(models, answer_cols))
+    
+    results = []
+    detail_dfs = []
+    
+    for model, column in model_mapping.items():
+        try:
+            model_results, detail_df = self.evaluate_model(df, model, prompt_col, column)
+            results.append(model_results)
+            detail_dfs.append(detail_df)
+            print(f"Completed evaluation for {model}")
+        except Exception as e:
+            print(f"Error evaluating {model}: {str(e)}")
+    
+    # Create combined results DataFrame
+    benchmark_df = pd.DataFrame([{
+        'model': r['model'],
+        'creativity_score': r['creativity_score'],
+        'stability_score': r['stability_score'],
+        'combined_score': r['combined_score'],
+        'evaluation_timestamp': r['evaluation_timestamp']
+    } for r in results])
+    
+    timestamp = pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')
+    benchmark_df.to_csv(f'results/benchmark_results_{timestamp}.csv', index=False)
+    print(f"Benchmark completed. Results saved to results/benchmark_results_{timestamp}.csv")
+    
+    if detail_dfs:
+        combined_details = pd.concat(detail_dfs)
+        combined_details.to_csv(f'results/detailed_evaluation_{timestamp}.csv', index=False)
+        print(f"Detailed evaluation saved to results/detailed_evaluation_{timestamp}.csv")
+    
+    return benchmark_df, self.leaderboard_df
+
+def get_leaderboard(self):
+    """Return the current leaderboard"""
+    if self.leaderboard_df.empty:
+        return pd.DataFrame(columns=['model', 'creativity_score', 'stability_score', 'combined_score', 'evaluation_timestamp'])
+    
+    # Sort by combined score (descending)
+    sorted_df = self.leaderboard_df.sort_values(by='combined_score', ascending=False)
+    return sorted_df
 
 
 def create_gradio_interface():
+    os.makedirs('results', exist_ok=True)
+    
+    state = {
+        'evaluator': None,
+        'last_results': None,
+        'leaderboard': None
+    }
+    
+    # Load existing leaderboard if available
+    leaderboard_path = 'results/benchmark_results.csv'
+    if os.path.exists(leaderboard_path):
+        try:
+            state['leaderboard'] = pd.read_csv(leaderboard_path)
+        except:
+            state['leaderboard'] = pd.DataFrame(columns=['model', 'creativity_score', 'stability_score', 'combined_score', 'evaluation_timestamp'])
+    else:
+        state['leaderboard'] = pd.DataFrame(columns=['model', 'creativity_score', 'stability_score', 'combined_score', 'evaluation_timestamp'])
+    
     with gr.Blocks(title="Model Response Evaluator") as app:
         gr.Markdown("# Model Response Evaluator")
         gr.Markdown("Upload a CSV file with prompts and model responses to evaluate and benchmark models.")
@@ -301,37 +388,105 @@ def create_gradio_interface():
         with gr.Row():
             csv_file = gr.File(label="Upload CSV with responses")
             prompt_col = gr.Textbox(label="Prompt Column Name", value="rus_prompt")
-            models_input = gr.Textbox(label="Model names (comma-separated, leave blank for auto-detection)")
+        
+        with gr.Row():
+            model_input_method = gr.Radio(
+                choices=["Auto-detect from columns", "Specify models and columns"],
+                label="Model Input Method",
+                value="Auto-detect from columns"
+            )
+        
+        with gr.Row(visible=False) as model_config_row:
+            models_input = gr.Textbox(label="Model names (comma-separated)")
+            answer_cols_input = gr.Textbox(label="Answer column names (comma-separated, matching model order)")
         
         evaluate_btn = gr.Button("Run Benchmark")
         
-        with gr.Row():
-            benchmark_output = gr.DataFrame(label="Benchmark Results")
+        with gr.Tabs():
+            with gr.Tab("Current Results"):
+                current_results = gr.DataFrame(label="Current Benchmark Results")
+                download_btn = gr.Button("Download Results CSV")
+                current_results_file = gr.File(label="Download Results")
+            
+            with gr.Tab("Leaderboard"):
+                leaderboard_table = gr.DataFrame(value=state['leaderboard'], label="Model Leaderboard")
+                refresh_btn = gr.Button("Refresh Leaderboard")
+        
+        def toggle_model_input(choice):
+            return gr.Row(visible=(choice == "Specify models and columns"))
+        
+        model_input_method.change(toggle_model_input, model_input_method, model_config_row)
         
-        def evaluate_batch(api_key, file, prompt_column, models_text):
+        def evaluate_batch(api_key, file, prompt_column, input_method, models_text, answer_cols_text):
             try:
+                if not api_key:
+                    return None, None, gr.DataFrame(), gr.File()
+                
                 # Load the CSV file
                 file_path = file.name
                 df = pd.read_csv(file_path)
                 
-                # Process model names if provided
-                models = None
-                if models_text.strip():
+                # Initialize evaluator
+                state['evaluator'] = BenchmarkEvaluator(api_key)
+                
+                # Process model names and columns if provided
+                if input_method == "Specify models and columns":
+                    if not models_text.strip() or not answer_cols_text.strip():
+                        return None, None, gr.DataFrame(), gr.File()
+                    
                     models = [m.strip() for m in models_text.split(',')]
+                    answer_cols = [c.strip() for c in answer_cols_text.split(',')]
+                    
+                    if len(models) != len(answer_cols):
+                        return None, None, gr.DataFrame(pd.DataFrame({'Error': ['Number of models and answer columns must match']})), gr.File()
+                    
+                    results_df, leaderboard_df = state['evaluator'].evaluate_all_models(
+                        df, models=models, model_columns=answer_cols, prompt_col=prompt_column
+                    )
+                else:
+                    # Auto-detect mode
+                    results_df, leaderboard_df = state['evaluator'].evaluate_all_models(
+                        df, prompt_col=prompt_column
+                    )
                 
-                # Run the evaluation
-                evaluator = BenchmarkEvaluator(api_key)
-                results = evaluator.evaluate_all_models(df, models, prompt_column)
+                timestamp = pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')
+                results_path = f'results/benchmark_results_{timestamp}.csv'
+                results_df.to_csv(results_path, index=False)
                 
-                return results
+                # Update state
+                state['last_results'] = results_df
+                state['leaderboard'] = leaderboard_df
+                
+                return results_df, leaderboard_df, results_path, leaderboard_df
             except Exception as e:
-                return pd.DataFrame({'Error': [str(e)]})
+                error_df = pd.DataFrame({'Error': [str(e)]})
+                return error_df, state['leaderboard'], gr.DataFrame(), gr.File()
+        
+        def download_results():
+            if state['last_results'] is not None:
+                timestamp = pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')
+                file_path = f'results/benchmark_download_{timestamp}.csv'
+                state['last_results'].to_csv(file_path, index=False)
+                return file_path
+            return None
+        
+        def refresh_leaderboard():
+            # Reload leaderboard from file
+            if os.path.exists('results/benchmark_results.csv'):
+                state['leaderboard'] = pd.read_csv('results/benchmark_results.csv')
+            return state['leaderboard']
         
         evaluate_btn.click(
             evaluate_batch,
-            inputs=[gemini_api_key, csv_file, prompt_col, models_input],
-            outputs=benchmark_output
+            inputs=[gemini_api_key, csv_file, prompt_col, model_input_method, models_input, answer_cols_input],
+            outputs=[current_results, leaderboard_table, gr.DataFrame(), current_results_file]
         )
+        
+        download_btn.click(download_results, inputs=[], outputs=[current_results_file])
+        refresh_btn.click(refresh_leaderboard, inputs=[], outputs=[leaderboard_table])
+        
+        # Initialize the leaderboard
+        leaderboard_table.value = state['leaderboard']
 
     return app