Separation of response and score in predictions.jsonl and summary.jsonl

src/benchmark_runner.py

@@ -93,27 +93,35 @@ def load_config(config_path: str) -> dict:
 
 def append_prediction(result: Dict[str, Any], filepath: str):
     """Appends a single prediction result to a JSONL file."""
+    # Create a copy to avoid modifying the original dict that might be used elsewhere
+    # and remove evaluation-specific fields before saving to predictions.jsonl
+    prediction_data = result.copy()
+    prediction_data.pop('marks_awarded', None)
+    prediction_data.pop('evaluation_status', None)
+    prediction_data.pop('predicted_answer', None) # Remove predicted_answer
+    prediction_data.pop('ground_truth', None) # Remove ground_truth
     try:
         with open(filepath, 'a') as f:
-            json.dump(result, f)
+            json.dump(prediction_data, f)
             f.write('\n')
     except IOError as e:
         logging.error(f"Failed to append prediction to {filepath}: {e}")
     except Exception as e:
         logging.error(f"Unexpected error appending prediction to {filepath}: {e}")
 
-
-def save_summary(summary: Dict[str, Any], filepath: str):
-    """Saves the final summary dictionary to a JSON file."""
+def append_summary_detail(result_detail: Dict[str, Any], filepath: str):
+    """Appends a single question's summary details (evaluation status, marks, predicted, truth) to a JSONL file."""
     try:
-        with open(filepath, 'w') as f:
-            json.dump(summary, f, indent=4)
-        logging.info(f"Summary results saved to {filepath}")
+        with open(filepath, 'a') as f:
+            json.dump(result_detail, f)
+            f.write('\n')
     except IOError as e:
-        logging.error(f"Failed to save summary results to {filepath}: {e}")
+        logging.error(f"Failed to append summary detail to {filepath}: {e}")
     except Exception as e:
-        logging.error(f"Unexpected error saving summary to {filepath}: {e}")
+        logging.error(f"Unexpected error appending summary detail to {filepath}: {e}")
+
 
+# Removed save_summary function as summary.json is no longer needed.
 
 def generate_markdown_summary(summary: Dict[str, Any], filepath: str):
     """Generates a human-readable Markdown summary from the results dictionary."""
@@ -125,7 +133,6 @@ def generate_markdown_summary(summary: Dict[str, Any], filepath: str):
         timestamp = summary.get("timestamp", "N/A")
         total_questions_in_dataset = summary.get("total_questions_in_dataset", 0)
         total_questions_processed_in_run = summary.get("total_questions_processed_in_run", 0)
-        # total_api_cost = summary.get("total_api_cost", 0.0) # Removed
 
         filtered_questions_count = 0
         if total_questions_in_dataset > 0 and total_questions_processed_in_run > 0:
@@ -149,14 +156,8 @@ def generate_markdown_summary(summary: Dict[str, Any], filepath: str):
         if "overall_score" in summary and "section_breakdown" in summary: # Generic check for score-based summary
             total_processed = summary.get("total_questions_processed", 0)
             
-            # Max score calculation is complex due to varied scoring per question.
-            # For now, we'll omit max_score from the overall display or acknowledge its variability.
-            # A more accurate max_score would require iterating through the dataset items used in the run
-            # and summing their individual max possible scores based on exam_name and question_type.
-            # This is out of scope for the current summary generation simplicity.
-            max_score_display = "N/A (variable per question)" # Placeholder
-
             overall_score = summary.get('overall_score', 'N/A')
+            total_possible_score = summary.get('total_possible_score_for_processed_questions', 'N/A')
             correct_full_count = summary.get('overall_correct_full', 'N/A')
             partial_correct_count = summary.get('overall_partial_correct', 'N/A')
             incorrect_choice_count = summary.get('overall_incorrect_choice', 'N/A')
@@ -164,10 +165,10 @@ def generate_markdown_summary(summary: Dict[str, Any], filepath: str):
             failures_count = summary.get('overall_api_parse_failures', 'N/A')
             unmapped_count = summary.get('unmapped_section_questions', 'N/A')
 
-            md_content.append("## Exam Scoring Results") # Changed from NEET
-            md_content.append(f"**Overall Score:** **{overall_score}** (Max score varies based on question types)")
+            md_content.append("## Exam Scoring Results")
+            md_content.append(f"**Overall Score:** **{overall_score}** / **{total_possible_score}**")
             md_content.append(f"- **Fully Correct Answers:** {correct_full_count}")
-            if partial_correct_count != 'N/A' and partial_correct_count > 0 : # Only show if applicable
+            if partial_correct_count != 'N/A' and partial_correct_count > 0 :
                 md_content.append(f"- **Partially Correct Answers:** {partial_correct_count}")
             md_content.append(f"- **Incorrectly Answered (Choice Made):** {incorrect_choice_count}")
             md_content.append(f"- **Skipped Questions:** {skipped_count}")
@@ -176,6 +177,53 @@ def generate_markdown_summary(summary: Dict[str, Any], filepath: str):
             if unmapped_count > 0:
                 md_content.append(f"- **Unmapped Section Questions:** {unmapped_count} *(Not included in section breakdown)*")
 
+            md_content.append("\n### Detailed Score Calculation by Question Type")
+            question_type_breakdown = summary.get("question_type_breakdown", {})
+            if question_type_breakdown:
+                sorted_q_types = sorted(question_type_breakdown.keys())
+                for q_type in sorted_q_types:
+                    stats = question_type_breakdown[q_type]
+                    q_type_display = q_type.replace('_', ' ').title()
+                    max_score_per_q = stats.get('max_score_per_question', 0)
+                    
+                    correct_count_q = stats.get('correct_full', 0)
+                    partial_count_q = stats.get('partial_correct', 0)
+                    incorrect_count_q = stats.get('incorrect_choice', 0)
+                    skipped_count_q = stats.get('skipped', 0)
+                    api_fail_count_q = stats.get('api_parse_failures', 0)
+                    score_q = stats.get('score', 0)
+
+                    calculation_parts = []
+                    if correct_count_q > 0:
+                        calculation_parts.append(f"{correct_count_q} Correct (+{max_score_per_q})")
+                    if partial_count_q > 0:
+                        # For partial, we can't easily show the exact score per question without more detail
+                        # For now, just indicate partials.
+                        calculation_parts.append(f"{partial_count_q} Partial")
+                    if incorrect_count_q > 0:
+                        # Need to know penalty for incorrect. Assuming -1 for MCQ_SINGLE_CORRECT, -2 for MCQ_MULTIPLE_CORRECT
+                        # For INTEGER, penalty is 0. This needs to be more robust if penalties vary.
+                        penalty_per_incorrect = 0
+                        if q_type == "MCQ_SINGLE_CORRECT": penalty_per_incorrect = -1
+                        elif q_type == "MCQ_MULTIPLE_CORRECT": penalty_per_incorrect = -2
+                        calculation_parts.append(f"{incorrect_count_q} Incorrect ({penalty_per_incorrect})")
+                    if skipped_count_q > 0:
+                        calculation_parts.append(f"{skipped_count_q} Skipped (0)")
+                    if api_fail_count_q > 0:
+                        # Assuming -1 for API/Parse failures for non-integer types, 0 for integer
+                        penalty_per_api_fail = -1
+                        if q_type == "INTEGER": penalty_per_api_fail = 0
+                        calculation_parts.append(f"{api_fail_count_q} API/Parse Fail ({penalty_per_api_fail})")
+                    
+                    calculation_str = " + ".join(part for part in calculation_parts if part)
+                    if not calculation_str:
+                        calculation_str = "No questions of this type processed or all had 0 score change."
+
+                    md_content.append(f"**{q_type_display} ({stats.get('count', 0)} questions):** {score_q} marks")
+                    md_content.append(f"  *Calculation:* {calculation_str} = {score_q}")
+            else:
+                md_content.append("No question type breakdown available.")
+
             md_content.append("\n### Section Breakdown")
             md_content.append("| Section       | Score | Fully Correct | Partially Correct | Incorrect Choice | Skipped | API/Parse Failures |")
             md_content.append("|---------------|-------|---------------|-------------------|------------------|---------|--------------------|")
@@ -189,9 +237,9 @@ def generate_markdown_summary(summary: Dict[str, Any], filepath: str):
             for section_name in sorted_section_names:
                 stats = section_breakdown.get(section_name, {})
                 score = stats.get('score', 'N/A')
-                s_correct = stats.get('correct', 'N/A') # This is full correct from new structure
+                s_correct = stats.get('correct', 'N/A')
                 s_partial = stats.get('partial_correct', 'N/A')
-                s_incorrect = stats.get('incorrect', 'N/A') # This is incorrect choice from new structure
+                s_incorrect = stats.get('incorrect', 'N/A')
                 s_skipped = stats.get('skipped', 'N/A')
                 s_failures = stats.get('api_parse_failures', 'N/A')
                 display_section_name = section_name.replace('_', ' ')
@@ -200,7 +248,7 @@ def generate_markdown_summary(summary: Dict[str, Any], filepath: str):
                 md_content.append("| No section data available | N/A   | N/A           | N/A               | N/A              | N/A     | N/A                |")
         
         # Fallback for simple accuracy (if exam scoring wasn't applicable or failed)
-        elif "accuracy_on_parsed" in summary: # This branch might be less used if all datasets now have exam_name/type
+        elif "accuracy_on_parsed" in summary:
             md_content.append("## Simple Accuracy Results (Fallback)")
             md_content.append(f"- **Accuracy (on successfully parsed non-skipped):** {summary.get('accuracy_on_parsed', 'N/A'):.4f}")
             md_content.append(f"- **Total Processed Attempts:** {summary.get('total_processed_attempts', 'N/A')}")
@@ -320,7 +368,7 @@ def run_benchmark(
         model_output_dir = os.path.join(base_output_dir, model_output_dir_name)
         os.makedirs(model_output_dir, exist_ok=True)
         predictions_path = os.path.join(model_output_dir, "predictions.jsonl")
-        summary_path = os.path.join(model_output_dir, "summary.json")
+        summary_details_path = os.path.join(model_output_dir, "summary.jsonl") # New file for per-question summary details
         markdown_summary_path = os.path.join(model_output_dir, "summary.md") # Define path for MD summary
         logging.info(f"Results for {model_id} will be saved to: {model_output_dir}")
 
@@ -447,8 +495,19 @@ def run_benchmark(
                 result_data['marks_awarded'] = score_details.get('marks_awarded')
                 result_data['evaluation_status'] = score_details.get('evaluation_status')
 
+                # Append evaluation details to summary.jsonl
+                summary_detail_data = {
+                    "question_id": question_id,
+                    "marks_awarded": result_data['marks_awarded'],
+                    "evaluation_status": result_data['evaluation_status'],
+                    "predicted_answer": result_data['predicted_answer'], # Add predicted_answer
+                    "ground_truth": result_data['ground_truth'], # Add ground_truth
+                    "attempt": result_data['attempt']
+                }
+                append_summary_detail(summary_detail_data, summary_details_path)
+
                 model_results.append(result_data)
-                append_prediction(result_data, predictions_path)
+                append_prediction(result_data, predictions_path) # append_prediction now handles removing evaluation fields
 
                 final_parsed_answer = result_data["predicted_answer"]
                 log_message_prefix = f"Question {question_id}:"
@@ -626,8 +685,19 @@ def run_benchmark(
                 result_data_retry['marks_awarded'] = score_details_retry.get('marks_awarded')
                 result_data_retry['evaluation_status'] = score_details_retry.get('evaluation_status')
 
+                # Append evaluation details to summary.jsonl for retry pass
+                summary_detail_data_retry = {
+                    "question_id": question_id_retry,
+                    "marks_awarded": result_data_retry['marks_awarded'],
+                    "evaluation_status": result_data_retry['evaluation_status'],
+                    "predicted_answer": result_data_retry['predicted_answer'], # Add predicted_answer
+                    "ground_truth": result_data_retry['ground_truth'], # Add ground_truth
+                    "attempt": result_data_retry['attempt']
+                }
+                append_summary_detail(summary_detail_data_retry, summary_details_path)
+
                 model_results.append(result_data_retry)
-                append_prediction(result_data_retry, predictions_path)
+                append_prediction(result_data_retry, predictions_path) # append_prediction now handles removing evaluation fields
 
                 # Logging for retry pass
                 log_message_prefix_retry = f"Question {question_id_retry} (Retry):"
@@ -709,24 +779,14 @@ def run_benchmark(
         logging.info(json.dumps(summary, indent=2, sort_keys=True))
         logging.info("-------------------------------------")
 
-        # --- Overwrite predictions file with final evaluated results ---
-        # The model_results list was modified in-place by calculate_neet_scores (if applicable)
+        # The model_results list was modified in-place by calculate_exam_scores
         # to include evaluation_status and marks_awarded.
-        logging.info(f"Overwriting {predictions_path} with final evaluated results...")
-        try:
-            with open(predictions_path, 'w') as f:
-                for final_result in model_results:
-                    json.dump(final_result, f)
-                    f.write('\n')
-            logging.info(f"Successfully updated {predictions_path} with evaluation details.")
-        except IOError as e:
-            logging.error(f"Failed to overwrite predictions file {predictions_path}: {e}")
-        except Exception as e:
-            logging.error(f"Unexpected error overwriting predictions file {predictions_path}: {e}")
+        # predictions.jsonl is now written incrementally without evaluation details.
+        # No need to overwrite predictions.jsonl here.
 
 
-        # Save final summary (JSON and Markdown) for the current model
-        save_summary(summary, summary_path)
+        # Save final summary (Markdown) for the current model
+        # The summary.json file is no longer generated as per user request.
         generate_markdown_summary(summary, markdown_summary_path) # Call the new function
 
     logging.info("Benchmark run completed.")

src/evaluation.py

@@ -201,9 +201,34 @@ def calculate_single_question_score_details(result_item: Dict[str, Any]) -> Dict
     return {"marks_awarded": current_score_change, "evaluation_status": evaluation_status}
 
 
+def calculate_max_score_for_question(exam_name: str, question_type: str) -> int:
+    """
+    Returns the maximum possible score for a given exam and question type.
+    """
+    exam_name = exam_name.upper()
+    question_type = question_type.upper()
+
+    if exam_name == "NEET" and question_type == "MCQ_SINGLE_CORRECT":
+        return 4
+    elif exam_name == "JEE_MAIN":
+        if question_type == "MCQ_SINGLE_CORRECT":
+            return 4
+        elif question_type == "INTEGER":
+            return 4
+    elif exam_name == "JEE_ADVANCED":
+        if question_type == "MCQ_SINGLE_CORRECT":
+            return 3
+        elif question_type == "INTEGER":
+            return 4
+        elif question_type == "MCQ_MULTIPLE_CORRECT":
+            return 4 # Max score for multiple correct is 4
+    return 0 # Default for unknown types
+
+
 def calculate_exam_scores(results: List[Dict[str, Any]]) -> Dict[str, Any]:
     """
-    Calculates exam scores based on exam_name and question_type, providing section-wise breakdown.
+    Calculates exam scores based on exam_name and question_type, providing section-wise breakdown
+    and detailed question type statistics.
 
     Args:
         results (List[Dict[str, Any]]): A list of result dictionaries. Each dict must contain:
@@ -217,14 +242,25 @@ def calculate_exam_scores(results: List[Dict[str, Any]]) -> Dict[str, Any]:
             This list will be modified in-place to add 'evaluation_status' and 'marks_awarded' by calling
             calculate_single_question_score_details for each item.
     Returns:
-        Dict[str, Any]: A dictionary containing overall and section-wise scores and counts.
+        Dict[str, Any]: A dictionary containing overall and section-wise scores and counts,
+                        plus question type breakdowns and total possible score.
     """
     if not results:
         return {"error": "No results provided."}
 
-    overall_stats = {"score": 0, "correct": 0, "incorrect": 0, "skipped": 0, "api_parse_failures": 0, "partial_correct": 0}
-    # total_api_cost = 0.0 # Removed
+    overall_stats = {
+        "score": 0,
+        "correct": 0,
+        "incorrect": 0,
+        "skipped": 0,
+        "api_parse_failures": 0,
+        "partial_correct": 0,
+        "total_possible_score": 0 # New field
+    }
     
+    # Initialize question type breakdown
+    question_type_breakdown: Dict[str, Dict[str, Any]] = {}
+
     valid_subjects_from_data = [r.get("subject") for r in results if r.get("subject") and isinstance(r.get("subject"), str) and r.get("subject").strip()]
     if not valid_subjects_from_data and results:
         logging.warning("No valid subjects found in results data to initialize section_stats.")
@@ -242,6 +278,8 @@ def calculate_exam_scores(results: List[Dict[str, Any]]) -> Dict[str, Any]:
     for result in results:
         question_id = result.get("question_id") # For logging within loop
         subject = result.get("subject") # For section mapping
+        exam_name = result.get("exam_name", "").upper()
+        question_type = result.get("question_type", "").upper()
 
         # Calculate score details for the single question
         score_details = calculate_single_question_score_details(result)
@@ -252,18 +290,12 @@ def calculate_exam_scores(results: List[Dict[str, Any]]) -> Dict[str, Any]:
         result['evaluation_status'] = evaluation_status
         result['marks_awarded'] = current_score_change
         
-        # Accumulate API cost # Removed
-        # current_api_cost = result.get("api_cost") # Removed
-        # if isinstance(current_api_cost, (int, float)): # Removed
-        #     total_api_cost += current_api_cost # Removed
-        # elif current_api_cost is not None: # Removed
-        #     logging.warning(f"Invalid api_cost type for QID {question_id}: {current_api_cost} (type: {type(current_api_cost)}). Skipping cost accumulation for this item.") # Removed
+        # Accumulate total possible score
+        overall_stats["total_possible_score"] += calculate_max_score_for_question(exam_name, question_type)
 
         # Determine boolean flags based on evaluation_status for aggregation
         is_correct_full = evaluation_status in ["correct", "correct_full"]
         is_partial_correct = evaluation_status.startswith("partial_")
-        # is_incorrect_choice needs to be inferred carefully if not directly returned by single calc
-        # For simplicity, we'll rely on the status. More robust would be for single_calc to return these bools too.
         is_incorrect_choice = evaluation_status in ["incorrect", "incorrect_negative"]
         is_skipped = evaluation_status == "skipped"
         is_api_parse_failure = evaluation_status in ["failure_api_or_parse", "failure_unexpected_type", "error_bad_ground_truth"]
@@ -276,6 +308,28 @@ def calculate_exam_scores(results: List[Dict[str, Any]]) -> Dict[str, Any]:
         if is_api_parse_failure: overall_stats["api_parse_failures"] += 1
         if is_partial_correct: overall_stats["partial_correct"] +=1
         
+        # Aggregate by question type
+        if question_type not in question_type_breakdown:
+            question_type_breakdown[question_type] = {
+                "count": 0,
+                "score": 0,
+                "correct_full": 0,
+                "partial_correct": 0,
+                "incorrect_choice": 0,
+                "skipped": 0,
+                "api_parse_failures": 0,
+                "max_score_per_question": calculate_max_score_for_question(exam_name, question_type)
+            }
+        
+        q_type_stats = question_type_breakdown[question_type]
+        q_type_stats["count"] += 1
+        q_type_stats["score"] += current_score_change
+        if is_correct_full: q_type_stats["correct_full"] += 1
+        if is_incorrect_choice: q_type_stats["incorrect_choice"] += 1
+        if is_skipped: q_type_stats["skipped"] += 1
+        if is_api_parse_failure: q_type_stats["api_parse_failures"] += 1
+        if is_partial_correct: q_type_stats["partial_correct"] += 1
+
         section = None
         if subject:
             question_num_for_log = -1 # Placeholder, as QID might not have number
@@ -309,9 +363,10 @@ def calculate_exam_scores(results: List[Dict[str, Any]]) -> Dict[str, Any]:
         "overall_skipped": overall_stats["skipped"],
         "overall_api_parse_failures": overall_stats["api_parse_failures"],
         "total_questions_processed": len(results),
-        # "total_api_cost": total_api_cost, # Removed
+        "total_possible_score_for_processed_questions": overall_stats["total_possible_score"], # New field
         "unmapped_section_questions": unmapped_section_questions,
-        "section_breakdown": section_stats
+        "section_breakdown": section_stats,
+        "question_type_breakdown": question_type_breakdown # New field
     }