Update app.py

app.py

@@ -47,38 +47,60 @@ class RAGEvaluator:
         self.current_dataset = None
         self.test_samples = []
         
-    def load_dataset(self, dataset_name: str, num_samples: int = 5): 
-        """Load a smaller subset of questions"""
-        if dataset_name == "squad":
-            dataset = load_dataset("squad_v2", split="validation")
-            # Select diverse questions based on length and type
-            samples = dataset.select(range(0, 1000, 100))[:num_samples]  # Take 10 spaced-out samples
-            self.test_samples = [
-                {
-                    "question": sample["question"],
-                    "ground_truth": sample["answers"]["text"][0] if sample["answers"]["text"] else "",
-                    "context": sample["context"]
-                }
-                for sample in samples
-                if sample["answers"]["text"]
-            ]
-        elif dataset_name == "msmarco":
-            dataset = load_dataset("ms_marco", "v2.1", split="train")
-            samples = dataset.select(range(0, 1000, 100))[:num_samples]
-            self.test_samples = [
-                {
-                    "question": sample["query"],
-                    "ground_truth": sample["answers"][0] if sample["answers"] else "",
-                    "context": sample["passages"]["passage_text"][0]
-                }
-                for sample in samples
-                if sample["answers"]
-            ]
-        self.current_dataset = dataset_name
-        return self.test_samples
+    def load_dataset(self, dataset_name: str, num_samples: int = 10):
+        """Load a smaller subset of questions with proper error handling"""
+        try:
+            if dataset_name == "squad":
+                dataset = load_dataset("squad_v2", split="validation")
+                # Select diverse questions
+                samples = dataset.select(range(0, 1000, 100))[:num_samples]
+                
+                self.test_samples = []
+                for sample in samples:
+                    # Check if answers exist and are not empty
+                    if sample.get("answers") and isinstance(sample["answers"], dict) and sample["answers"].get("text"):
+                        self.test_samples.append({
+                            "question": sample["question"],
+                            "ground_truth": sample["answers"]["text"][0],
+                            "context": sample["context"]
+                        })
+                
+            elif dataset_name == "msmarco":
+                dataset = load_dataset("ms_marco", "v2.1", split="dev")
+                samples = dataset.select(range(0, 1000, 100))[:num_samples]
+                
+                self.test_samples = []
+                for sample in samples:
+                    # Check for valid answers
+                    if sample.get("answers") and sample["answers"]:
+                        self.test_samples.append({
+                            "question": sample["query"],
+                            "ground_truth": sample["answers"][0],
+                            "context": sample["passages"][0]["passage_text"] 
+                                     if isinstance(sample["passages"], list) 
+                                     else sample["passages"]["passage_text"][0]
+                        })
+            
+            self.current_dataset = dataset_name
+            
+            # Return dataset info
+            return {
+                "dataset": dataset_name,
+                "num_samples": len(self.test_samples),
+                "sample_questions": [s["question"] for s in self.test_samples[:3]],
+                "status": "success"
+            }
+            
+        except Exception as e:
+            print(f"Error loading dataset: {str(e)}")
+            return {
+                "dataset": dataset_name,
+                "error": str(e),
+                "status": "failed"
+            }
 
     def evaluate_configuration(self, vector_db, qa_chain, splitting_strategy: str, chunk_size: str) -> Dict:
-        """Evaluate with progress tracking"""
+        """Evaluate with progress tracking and error handling"""
         if not self.test_samples:
             return {"error": "No dataset loaded"}
             
@@ -105,11 +127,17 @@ class RAGEvaluator:
                 print(f"Error processing question {i+1}: {str(e)}")
                 continue
         
-        # Calculate RAGAS metrics
-        eval_dataset = Dataset.from_list(results)
-        metrics = [ContextRecall(), AnswerRelevancy(), Faithfulness(), ContextPrecision()]
-        
+        if not results:
+            return {
+                "configuration": f"{splitting_strategy}_{chunk_size}",
+                "error": "No successful evaluations",
+                "questions_evaluated": 0
+            }
+            
         try:
+            # Calculate RAGAS metrics
+            eval_dataset = Dataset.from_list(results)
+            metrics = [ContextRecall(), AnswerRelevancy(), Faithfulness(), ContextPrecision()]
             scores = evaluate(eval_dataset, metrics=metrics)
             
             return {
@@ -417,12 +445,25 @@ def demo():
         )
 
         def load_dataset_handler(dataset_name):
-            samples = evaluator.load_dataset(dataset_name)
-            return {
-                "dataset": dataset_name,
-                "num_samples": len(samples),
-                "sample_questions": [s["question"] for s in samples[:3]]
-            }
+            try:
+                result = evaluator.load_dataset(dataset_name)
+                if result.get("status") == "success":
+                    return {
+                        "dataset": result["dataset"],
+                        "samples_loaded": result["num_samples"],
+                        "example_questions": result["sample_questions"],
+                        "status": "ready for evaluation"
+                    }
+                else:
+                    return {
+                        "error": result.get("error", "Unknown error occurred"),
+                        "status": "failed to load dataset"
+                    }
+            except Exception as e:
+                return {
+                    "error": str(e),
+                    "status": "failed to load dataset"
+                }
         
         def run_evaluation(dataset_choice, splitting_strategy, chunk_size, vector_db, qa_chain):
             if not evaluator.current_dataset: